pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/__init__.py

@@ -0,0 +1,44 @@
+from .african_vulture import *
+from .ant_colony import *
+from .aquila import *
+from .bacterial_foraging import *
+from .bat import *
+from .bee_colony import *
+from .camel_caravan import *
+from .coral_reef import *
+from .coyotes import *
+from .earthworms import *
+from .electromagnetic_field import *
+from .elephant_herd import *
+from .firefly_swarm import *
+from .fireworks import *
+from .fish_school_search import *
+from .flower_pollination_algorithm import *
+from .forest_algorithm import *
+from .fox import *
+from .genetic_algorithm import *
+from .grasshopper import *
+from .grey_wolf import *
+from .harmony_search import *
+from .imperialist_competitive import *
+from .invasive_weed import *
+from .krill_herd import *
+from .levi_jaya_swarm import *
+from .monarch_butterfly import *
+from .mountain_gazelle import *
+from .osprey import *
+from .particle_swarm import *
+from .pathfinder_algorithm import *
+from .pelican import *
+from .seagull import *
+from .siberian_tiger import *
+from .tasmanian_devil import *
+from .virus_colony_search import *
+from .walrus import *
+from .whales import *
+from .wildebeest_herd import *
+from .zebra import *
+from .enums import TaskType
+from .models import OptimizationResult, Population, Agent, Task, ContinuousVariable, DiscreteVariable
+from .helpers import best_agent, worst_agent, best_agents, worst_agents, special_agents
+from .utils import plot, animate, agent_trend, best_agent_trend

pyvolutionary/abstract.py

@@ -0,0 +1,325 @@
+from abc import ABC, abstractmethod
+from typing import Generic, Any
+import numpy as np
+import concurrent.futures as parallel
+
+from .enums import ModeSolver
+from .helpers import (
+    average_fitness,
+    calculate_fitness,
+    sort_and_trim,
+    sort_by_cost,
+    special_agents,
+)
+from .models import OptimizationResult, Population, T, BaseOptimizationConfig, Task, TaskType, Agent, ContinuousVariable
+
+
+class OptimizationAbstract(ABC, Generic[T]):
+    """
+    This class is an abstract for optimization algorithms.
+    """
+
+    def __init__(self, config: BaseOptimizationConfig, debug: bool | None = False):
+        """
+        The constructor of the class.
+        :param config: The configuration of the optimization algorithm.
+        :param debug: Whether to print debug messages or not.
+        """
+        self._config = config
+        self._debug = debug
+        self._mode: ModeSolver = ModeSolver.SERIAL
+        self._workers: int = 4
+        self._task: Task | None = None
+        self._population: list[T] = []
+        self._best_agent: T | None = None
+        self._worst_agent: T | None = None
+        self._cycles = 1
+
+    @abstractmethod
+    def optimization_step(self):
+        pass
+
+    def before_initialization(self):
+        pass
+
+    def after_initialization(self):
+        pass
+
+    def _get_bounds(self) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Get the lower and upper bounds of the search space.
+        :return: the lower and upper bounds
+        :rtype: tuple[np.ndarray, np.ndarray]
+        """
+        lb, ub = zip(*[
+            (v.lower_bound, v.upper_bound) if isinstance(v, ContinuousVariable) else (0, 0)
+            for v in self._task.variables
+        ])
+        return np.array(lb), np.array(ub)
+
+    def _init_position(self, position: list[float] | np.ndarray | None = None) -> list[float]:
+        """
+        This method initializes the position of the agent of the optimization algorithm. The position is randomly
+        generated if it is not provided.
+        :param position: the position to initialize
+        :return: the initialized position
+        :rtype: list[float]
+        """
+        position = position.tolist() if isinstance(position, np.ndarray) else position
+        position = self._correct_position(position if position is not None else self._uniform_position())
+
+        return position
+
+    def _uniform_position(self) -> np.ndarray:
+        """
+        This method generates a uniform random position in the search space.
+        :return: the random position
+        :rtype: np.ndarray
+        """
+        return np.array([v.randomize() for v in self._task.variables])
+
+    def _random_position(self) -> np.ndarray:
+        """
+        This method generates a random position in the search space.
+        :return: the random position
+        :rtype: np.ndarray
+        """
+        lb, _ = self._get_bounds()
+        return np.where(
+            isinstance(self._task.variables, ContinuousVariable),
+            np.random.random() * self._bandwidth() + lb,
+            self._uniform_position()
+        )
+
+    def _increase_position(self, position: list[float], scale_factor: float | None = None) -> np.ndarray:
+        """
+        This method increases the position in the search space.
+        :param position: the position to increase
+        :param scale_factor: the scale factor
+        :return: the increased position
+        :rtype: np.ndarray
+        """
+        scale_factor = scale_factor if scale_factor is not None else 1.0
+        return np.where(
+            isinstance(self._task.variables, ContinuousVariable),
+            np.array(position) + self._random_position() / scale_factor,
+            self._uniform_position()
+        )
+
+    def _uniform_coordinates(self, dimensions: int | list[int]) -> np.ndarray:
+        """
+        This method generates uniform random coordinates in the search space.
+        :param dimensions: the dimensions to generate
+        :return: the random coordinates
+        :rtype: np.ndarray
+        """
+        return self._uniform_position()[dimensions]
+
+    def _bandwidth(self) -> np.ndarray:
+        """
+        This method calculates the bandwidth in the search space for each dimension.
+        :return: the bandwidth
+        :rtype: np.ndarray
+        """
+        lb, ub = self._get_bounds()
+        return ub - lb
+
+    def _sum_bounds(self) -> np.ndarray:
+        """
+        This method calculates the sum of the lower and upper bounds in the search space for each dimension.
+        :return: the sum of the lower and upper bounds
+        :rtype: np.ndarray
+        """
+        lb, ub = self._get_bounds()
+        return lb + ub
+
+    def _fcn(self, x: list[float] | np.ndarray) -> float:
+        """
+        This method evaluates the objective function.
+        :param x: the position to evaluate
+        """
+        return self._task.objective_function(x) \
+            if self._task.minmax == TaskType.MIN else -self._task.objective_function(x)
+
+    def _init_agent(self, position: list[float] | np.ndarray | None = None) -> Agent:
+        """
+        This method initializes the agent of the optimization algorithm. The position is randomly generated if it is
+        not provided. The other properties of the agent.
+        """
+        position = self._init_position(position)
+        cost = self._fcn(position)
+        return Agent(position=position, cost=cost, fitness=calculate_fitness(cost, self._task.minmax))
+
+    def _init_population(self):
+        """
+        This method initializes the population of the optimization algorithm.
+        """
+        # Serial mode
+        if self._mode == ModeSolver.SERIAL:
+            self._population = [self._init_agent() for _ in range(0, self._config.population_size)]
+            return
+
+        # Parallel mode
+        pop = []
+        pool = parallel.ThreadPoolExecutor if self._mode == ModeSolver.THREAD else parallel.ProcessPoolExecutor
+        with pool(self._workers) as executor:
+            executors = [executor.submit(self._init_agent) for _ in range(0, self._config.population_size)]
+            for i in parallel.as_completed(executors):
+                pop.append(i.result())
+        self._population = pop
+
+    def _is_valid_position(self, position: list[float] | np.ndarray) -> bool:
+        """
+        Check whether the position is valid or not.
+        :param position: the position to check
+        :return: whether the position is valid or not
+        """
+        lb, ub = self._get_bounds()
+        return np.all(np.less_equal(lb, position)) and np.all(np.less_equal(position, ub))
+
+    def _greedy_select_population(self, new_population: list[T]):
+        """
+        Perform the greedy selection between the current population and the new one. Both are sorted by cost in
+        ascending order. The greedy selection is performed by comparing the costs of each agent in the current
+        population with the corresponding agent in the new population. The one with the lowest cost is kept.
+        The new population is so created.
+        :param new_population: the new population
+        """
+        sort_by_cost(self._population)
+        sort_by_cost(new_population)
+
+        # Serial mode
+        if self._mode == ModeSolver.SERIAL:
+            self._population = [
+                self._greedy_select_agent(agent, new_population[idx]) for idx, agent in enumerate(self._population)
+            ]
+            return
+
+        # Parallel mode
+        pop = []
+        pool = parallel.ThreadPoolExecutor if self._mode == ModeSolver.THREAD else parallel.ProcessPoolExecutor
+        with pool(self._workers) as executor:
+            executors = [executor.submit(
+                self._greedy_select_agent, agent, new_population[idx]
+            ) for idx, agent in enumerate(self._population)]
+            for i in parallel.as_completed(executors):
+                pop.append(i.result())
+        self._population = pop
+
+    def _greedy_select_agent(self, agent: T, new_agent: T) -> T:
+        """
+        Perform the greedy selection between the current agent and the new one. The greedy selection is performed by
+        comparing the costs of each agent. The one with the lowest cost is kept.
+        :param agent: the current agent
+        :param new_agent: the new agent
+        :return: the best agent
+        """
+        agent_copy = agent.model_copy()
+        return new_agent if new_agent.cost < agent_copy.cost else agent_copy
+
+    def _correct_position(self, position: list[float] | np.ndarray) -> list[Any]:
+        """
+        Correct the solution if it is outside the bounds by setting the solution to the closest bound. This function is
+        used to correct the solution after the position update.
+        :param position: the position
+        :return: the corrected position
+        :rtype: list[Any]
+        """
+        variables = self._task.variables
+        return [
+            np.clip(p, variables[idx].lower_bound, variables[idx].upper_bound)
+            if isinstance(variables[idx], ContinuousVariable) else p
+            for idx, p in enumerate(position)
+        ]
+
+    def _extend_and_trim_population(self, new_population: list[T]):
+        """
+        Extend the population with the new population and trim the population to the population size if the population
+        size is exceeded. The population is sorted by cost in ascending order.
+        :param new_population: the new population
+        """
+        self._population.extend(new_population)
+        self._population = sort_and_trim(self._population, self._config.population_size)
+
+    def optimize(self, task: Task, mode: str | None = None, workers: int | None = None) -> OptimizationResult:
+        """
+        This method optimizes the given objective function. At the beginning, a random population is generated and then
+        the optimization algorithm is executed. The returned result contains the evolution of the population and the
+        best solution found. A list of errors per cycle is also returned in the result itself.
+        :param task: the task to optimize
+        :param mode, the mode of the solver; possible values are "serial", "thread" and "process"
+        :param workers: the number of workers to use, in case of parallel or thread execution
+        :return: the result of the optimization
+        :rtype: OptimizationResult
+        """
+        np.random.seed(task.seed)
+
+        evolution: list[Population] = []
+
+        self._task = task
+        if workers is not None:
+            if workers <= 0:
+                raise ValueError("Invalid number of workers. It must be greater than 0")
+            self._workers = workers
+
+        if mode is not None:
+            try:
+                self._mode = ModeSolver(mode)
+            except ValueError:
+                raise ValueError("Invalid mode. Possible values are 'serial', 'thread' and 'process'")
+
+        self.before_initialization()
+        self._init_population()
+        self.after_initialization()
+
+        evolution.append(Population(agents=self._population, task_type=task.minmax))
+        (self._best_agent, ), (self._worst_agent, ) = special_agents(self._population, n_best=1, n_worst=1)
+
+        errors: list[float] = []
+        while True:
+            self.optimization_step()
+            # append the current population to the evolution, being sure that costs and fitness are updated
+            evolution.append(Population(agents=self._population, task_type=task.minmax))
+
+            (self._best_agent, ), (self._worst_agent, ) = special_agents(self._population, n_best=1, n_worst=1)
+
+            # stop when the error is below the error criteria or when the maximum number of cycles is reached
+            error, fitness, has_to_stop = self.__should_stop__()
+            errors.append(error)
+            if self._debug:
+                print(f"Cycle {self._cycles} - Best position {self._best_agent.position}, "
+                      f"cost {self._best_agent.cost if task.minmax == TaskType.MIN else -self._best_agent.cost} - "
+                      f"Average fitness {fitness}, fitness error {error}")
+            if has_to_stop:
+                break
+
+            self._cycles += 1
+
+        if has_to_stop and self._debug:
+            print("Maximum number of cycles reached" if self._cycles >= self._config.max_cycles else
+                  f"Error criteria reached - Fitness error: {error}")
+
+        return OptimizationResult(
+            evolution=evolution, rates=errors, best_solution=self._best_agent, task_type=task.minmax
+        )
+
+    def __should_stop__(self) -> tuple[float, float, bool]:
+        """
+        Check whether the optimization algorithm has to stop or not based on the error criteria and the current cycle.
+        :return: a tuple containing the current error, the average fitness and a boolean indicating whether the
+        algorithm has to stop or not
+        :rtype: tuple[float, float, bool]
+        """
+        # Get the optimal population
+        fitness_error = self._config.fitness_error
+        avg_fit = average_fitness(self._population)
+        cycle = self._cycles
+        max_cycles = self._config.max_cycles
+
+        current_error = abs(1 - avg_fit)
+
+        # Stop when the error is below the error criteria or when the maximum number of cycles is reached
+        if fitness_error is None:
+            return current_error, avg_fit, cycle >= max_cycles
+
+        return current_error, avg_fit, current_error <= fitness_error or cycle >= max_cycles

pyvolutionary/african_vulture/__init__.py

@@ -0,0 +1,2 @@
+from .models import AfricanVulture, AfricanVultureOptimizationConfig
+from .african_vulture_optimization import AfricanVultureOptimization

pyvolutionary/african_vulture/african_vulture_optimization.py

@@ -0,0 +1,87 @@
+import numpy as np
+
+from ..helpers import (
+    best_agents,
+    get_levy_flight_step,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import AfricanVulture, AfricanVultureOptimizationConfig
+
+
+class AfricanVultureOptimization(OptimizationAbstract):
+    """
+    Implementation of the African Vulture Optimization algorithm.
+
+    Args:
+        config (AfricanVultureOptimizationConfig): an instance of AfricanVultureOptimizationConfig class.
+            {parse_obj_doc(AfricanVultureOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Abdollahzadeh, B., Gharehchopogh, F. S., & Mirjalili, S. (2021). African vultures optimization algorithm: A new
+        nature-inspired metaheuristic algorithm for global optimization problems. Computers & Industrial Engineering,
+        158, 107408.
+    """
+    def __init__(self, config: AfricanVultureOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __exploration_position__(self, rand_pos: np.ndarray, position: np.ndarray, F: float) -> np.ndarray:
+        p1, _, _ = self._config.p
+        if np.random.random() < p1:
+            return rand_pos - (np.abs((2 * np.random.random()) * rand_pos - position)) * F
+
+        return rand_pos - F + np.random.random() * self._uniform_position()
+
+    def __exploration_position_phase1__(
+        self, best_list: list[AfricanVulture], rand_pos: np.ndarray, position: np.ndarray, F: float
+    ) -> np.ndarray:
+        _, p2, _ = self._config.p
+
+        best_x1 = np.array(best_list[0].position)
+        best_x2 = np.array(best_list[1].position)
+        if np.random.random() < p2:
+            A = best_x1 - ((best_x1 * position) / (best_x1 - position ** 2)) * F
+            B = best_x2 - ((best_x2 * position) / (best_x2 - position ** 2)) * F
+            return (A + B) / 2
+
+        return rand_pos - np.abs(rand_pos - position) * F * get_levy_flight_step(
+            beta=1.5, multiplier=1., size=self._task.space_dimension, case=-1
+        )
+
+    def __exploration_position_phase2__(self, rand_pos: np.ndarray, position: np.ndarray, F: float) -> np.ndarray:
+        _, _, p3 = self._config.p
+
+        if np.random.random() < p3:
+            return (
+                np.abs(2 * np.random.random() * rand_pos - position)
+            ) * (F + np.random.random()) - (rand_pos - position)
+
+        s1 = np.random.random() * position * np.cos(position)
+        s2 = np.random.random() * position * np.sin(position)
+        return rand_pos * (1 - ((s1 + s2) / (2 * np.pi)))
+
+    def optimization_step(self):
+        cycle_ratio = self._cycles / self._config.max_cycles
+        alpha = self._config.alpha
+
+        a = np.random.uniform(-2, 2) * (
+            (np.sin((np.pi / 2) * cycle_ratio) ** self._config.gamma) + np.cos((np.pi / 2) * cycle_ratio) - 1
+        )
+        ppp = (2 * np.random.random() + 1) * (1 - cycle_ratio) + a
+        best_list = best_agents(self._population, n_best=2)
+
+        for idx in range(0, self._config.population_size):
+            position = np.array(self._population[idx].position)
+
+            F = ppp * (2 * np.random.random() - 1)
+            rand_pos = np.array(best_list[np.random.choice([0, 1], p=[alpha, 1 - alpha])].position)
+
+            if np.abs(F) >= 1:  # Exploration
+                pos_new = self.__exploration_position__(rand_pos, position, F)
+            elif np.abs(F) < 0.5:  # Exploitation Phase 1
+                pos_new = self.__exploration_position_phase1__(best_list, rand_pos, position, F)
+            else:  # Exploitation Phase 2
+                pos_new = self.__exploration_position_phase2__(rand_pos, position, F)
+
+            self._population[idx] = self._greedy_select_agent(self._population[idx], self._init_agent(pos_new))

pyvolutionary/african_vulture/models.py

@@ -0,0 +1,41 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class AfricanVulture(Agent):
+    pass
+
+
+class AfricanVultureOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the African Vulture Optimization algorithm.
+        p (list[float]): (0, 1), (0, 1), (0, 1), list of 3 floats in [0, 1] that represent the probabilities of each of
+        the 3 status transition (see paper).\n
+        alpha (float): (0, 1), the alpha parameter of the algorithm, i.e. probability of 1st best (see paper).\n
+        gamma (float): (0, 5), the gamma parameter of the algorithm (see paper).
+    """
+    p: list[float]
+    alpha: float
+    gamma: float
+
+    @field_validator("p")
+    def correct_p(cls, v):
+        if len(v) != 3:
+            raise ValueError(f"\"p\" must be a list of 3 floats. Got {v}")
+        # check if any of v is not in [0, 1]
+        if any([not (0 < x < 1) for x in v]):
+            raise ValueError(f"\"p\" must be a list of 3 floats in [0, 1]. Got {v}")
+        return v
+
+    @field_validator("alpha")
+    def correct_alpha(cls, v):
+        if not (0 < v < 1):
+            raise ValueError(f"\"alpha\" must be a float in (0, 1). Got {v}")
+        return v
+
+    @field_validator("gamma")
+    def correct_gamma(cls, v):
+        if not (0 < v < 5):
+            raise ValueError(f"\"gamma\" must be a float in (0, 5). Got {v}")
+        return v

pyvolutionary/ant_colony/__init__.py

@@ -0,0 +1,2 @@
+from .models import Ant, AntColonyOptimizationConfig
+from .ant_colony_optimization import AntColonyOptimization

pyvolutionary/ant_colony/ant_colony_optimization.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+from ..helpers import (
+    roulette_wheel_index,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Ant, AntColonyOptimizationConfig
+
+
+class AntColonyOptimization(OptimizationAbstract):
+    """
+    Implementation of the Ant Colony Optimization algorithm.
+
+    Args:
+        config (AntColonyOptimizationConfig): an instance of AntColonyOptimizationConfig class.
+            {parse_obj_doc(AntColonyOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] A. Colorni, M. Dorigo et V. Maniezzo, Distributed Optimization by Ant Colonies, actes de la première conférence
+        européenne sur la vie artificielle, Paris, France, Elsevier Publishing, 134-142, 1991.
+    [2] M. Dorigo, Optimization, Learning and Natural Algorithms, PhD thesis, Politecnico di Milano, Italy, 1992.
+    """
+    def __init__(self, config: AntColonyOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __selection_probability__(self) -> np.ndarray:
+        """
+        Compute the selection probability of each ant in the population.
+        :return: a numpy array of the selection probability of each ant in the population.
+        :rtype: np.ndarray
+        """
+        ranks = np.array([idx for idx in range(1, self._config.population_size + 1)])
+        Q = self._config.intent_factor * self._config.population_size
+        weights = 1 / (np.sqrt(2 * np.pi) * Q) * np.exp(-0.5 * ((ranks - 1) / Q) ** 2)
+        return weights / np.sum(weights)  # Normalize to find the probability.
+
+    def __compute_sigmas__(self) -> np.ndarray:
+        """
+        Compute the sigmas of each ant in the population. Each sigma is computed as follows:
+            sigma_i = zeta * sum(|x_j - x_i|) / (N - 1)
+        where:
+            x_i: the position of the i-th ant.\n
+            x_j: the position of the j-th ant.\n
+            zeta: the zeta parameter of the colony.\n
+            N: the population size.
+        :return: a numpy array of the sigmas of each ant in the population.
+        :rtype: np.ndarray
+        """
+        positions = np.array([ant.position for ant in self._population])
+        pop_size = self._config.population_size
+
+        sigmas = []
+        for idx in range(0, self._config.population_size):
+            M = np.repeat(np.array(self._population[idx].position).reshape((1, -1)), pop_size, axis=0)
+            sigmas.append(
+                self._config.zeta * np.sum(np.abs(positions - M), axis=0) / (pop_size - 1)
+            )
+        return np.array(sigmas)
+
+    def __generate_new_ants__(self, weights: np.ndarray, sigmas: np.ndarray) -> list[Ant]:
+        def generate_coordinate(j: int) -> float:
+            rdx = roulette_wheel_index(weights)
+            return float(self._population[rdx].position[j] + np.random.normal() * sigmas[rdx, j])
+
+        # Generate Samples
+        return [Ant(**self._init_agent(
+            list(map(generate_coordinate, range(0, self._task.space_dimension)))
+        ).model_dump()) for _ in range(0, self._config.archive_size)]
+
+    def optimization_step(self):
+        weights = self.__selection_probability__()
+        sigmas = self.__compute_sigmas__()
+
+        # Generate new ants
+        new_ants = self.__generate_new_ants__(weights, sigmas)
+
+        self._extend_and_trim_population(new_ants)
+

pyvolutionary/ant_colony/models.py

@@ -0,0 +1,25 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Ant(Agent):
+    pass
+
+
+class AntColonyOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Ant Colony Optimization algorithm.
+        archive_size (int): the size of the archive of the colony.\n
+        intent_factor (float): [0, 1), the intent factor of the colony.\n
+        zeta (float): the zeta parameter of the colony.
+    """
+    archive_size: int
+    intent_factor: float
+    zeta: float
+
+    @field_validator("intent_factor")
+    def correct_intent_factor(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"intent_factor\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/aquila/__init__.py

@@ -0,0 +1,2 @@
+from .models import Aquila, AquilaOptimizationConfig
+from .aquila_optimization import AquilaOptimization