pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/genetic_algorithm/models.py

@@ -0,0 +1,21 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Gene(Agent):
+    pass
+
+
+class GeneticAlgorithmOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Genetic Algorithm.
+        px_over (float): [0, 1), probability of crossover between two genes.
+    """
+    px_over: float
+
+    @field_validator("px_over")
+    def correct_px_over(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"px_over\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/grasshopper/__init__.py

@@ -0,0 +1,2 @@
+from .models import Grasshopper, GrasshopperOptimizationConfig
+from .grasshopper_optimization_algorithm import GrasshopperOptimization

pyvolutionary/grasshopper/grasshopper_optimization_algorithm.py

@@ -0,0 +1,73 @@
+import numpy as np
+
+from ..helpers import (
+    distance,
+    verser,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import GrasshopperOptimizationConfig
+
+
+class GrasshopperOptimization(OptimizationAbstract):
+    """
+    Implementation of the Grasshopper Optimization Algorithm.
+
+    Args:
+        config (GrasshopperOptimizationConfig): an instance of GrasshopperOptimizationConfig class.
+            {parse_obj_doc(GrasshopperOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Saremi, S., Mirjalili, S. and Lewis, A., 2017. Grasshopper optimisation algorithm: theory and application.
+        Advances in Engineering Software, 105, pp.30-47.
+    """
+    def __init__(self, config: GrasshopperOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __s_function__(self, position: list[float], ran: np.ndarray):
+        """
+        Eq.(2.3) in the paper. This function is used to calculate the sum of the attraction forces between the current
+        grasshopper and the other grasshoppers in the population. The sum of the attraction forces is calculated by
+        multiplying the attraction force between the current grasshopper and each other grasshopper by the direction of
+        the attraction force. The direction of the attraction force is calculated by the verser of the vector between
+        the current grasshopper and each other grasshopper. The attraction force between the current grasshopper and
+        each other grasshopper is calculated by the Eq.(2.2) in the paper. The Eq.(2.2) is a function of the distance
+        between the current grasshopper and each other grasshopper. The distance between the current grasshopper and
+        each other grasshopper is calculated by the Eq.(2.1) in the paper. The Eq.(2.1) is a function of the position
+        of the current grasshopper and the position of each other grasshopper. The position of the current grasshopper
+        is the position of the current grasshopper in the current iteration. The position of each other grasshopper is
+        the position of each other grasshopper in the current iteration. The Eq.(2.3) is a function of the position of
+        the current grasshopper and the position of each other grasshopper. The position of the current grasshopper is
+        the position of the current grasshopper in the current iteration. The position of each other grasshopper is the
+        position of each other grasshopper in the current iteration.
+        :param position: the position of the current grasshopper in the current iteration.
+        :param ran: a random vector.
+        :return: the sum of the attraction forces between the current grasshopper and the other grasshoppers in the
+            population.
+        :rtype: np.ndarray
+        """
+        def f(r_vector: np.ndarray):
+            return 0.5 * np.exp(-r_vector / 1.5) - np.exp(-r_vector)
+
+        return np.sum([
+            ran * f(2 + np.remainder(distance(position, g.position), 2)) * verser(position, g.position)
+            for jdx, g in enumerate(self._population)
+        ], axis=0)
+
+    def optimization_step(self):
+        # Eq.(2.8)
+        c = self._config.c_max - self._cycles * ((self._config.c_max - self._config.c_min) / self._config.max_cycles)
+        ran = (c / 2) * self._bandwidth()
+
+        best_pos = np.array(self._best_agent.position)
+        for idx, grasshopper in enumerate(self._population):
+            sum_grass = self.__s_function__(grasshopper.position, ran)
+
+            # Eq. (2.7)
+            self._population[idx] = self._greedy_select_agent(
+                self._init_agent(self._correct_position(
+                    c * np.random.normal(0, 1, self._task.space_dimension) * sum_grass + best_pos
+                )),
+                grasshopper
+            )

pyvolutionary/grasshopper/models.py

@@ -0,0 +1,29 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Grasshopper(Agent):
+    pass
+
+
+class GrasshopperOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Grasshopper Optimization Algorithm.
+        c_min (float): [0.00001, 0.2], coefficient c min, default = 0.00004.\n
+        c_max (float): [0.2, 5.0], coefficient c max, default = 2.0.
+    """
+    c_min: float
+    c_max: float
+
+    @field_validator("c_min")
+    def validate_c_min(cls, v):
+        if not 0.00001 <= v <= 0.2:
+            raise ValueError("c_min must be in range [0.00001, 0.2].")
+        return v
+
+    @field_validator("c_max")
+    def validate_c_max(cls, v):
+        if not 0.2 <= v <= 5.0:
+            raise ValueError("c_max must be in range [0.2, 5.0].")
+        return v

pyvolutionary/grey_wolf/__init__.py

@@ -0,0 +1,2 @@
+from .models import GreyWolf, GreyWolfOptimizationConfig
+from .grey_wolf_optimization import GreyWolfOptimization

pyvolutionary/grey_wolf/grey_wolf_optimization.py

@@ -0,0 +1,62 @@
+import numpy as np
+
+from ..helpers import (
+    best_agents,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import GreyWolf, GreyWolfOptimizationConfig
+
+
+class GreyWolfOptimization(OptimizationAbstract):
+    """
+    Implementation of the Grey Wolf Optimization algorithm.
+
+    Args:
+        config (GreyWolfOptimizationConfig): an instance of GreyWolfOptimizationConfig class.
+            {parse_obj_doc(GreyWolfOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Mirjalili, S., Mirjalili, S. M., & Lewis, A. (2014). Grey wolf optimizer. Advances in engineering software, 69,
+        46-61. Chicago
+    """
+    def __init__(self, config: GreyWolfOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__alpha_wolf: GreyWolf | None = None
+        self.__beta_wolf: GreyWolf | None = None
+        self.__gamma_wolf: GreyWolf | None = None
+
+    def _init_population(self):
+        super()._init_population()
+        self.__alpha_wolf, self.__beta_wolf, self.__gamma_wolf = best_agents(self._population, 3)
+
+    def optimization_step(self):
+        """
+        Implementation of the Grey Wolf Optimization algorithm. [1]
+        """
+        # linearly decreased from 2 to 0
+        a = 2 * (1 - self._cycles / self._config.max_cycles)
+
+        # updating each population member with the help of best three members
+        for idx in range(0, self._config.population_size):
+            position = np.array(self._population[idx].position)
+            a1, a2, a3 = (a * (2 * np.random.random() - 1),
+                          a * (2 * np.random.random() - 1),
+                          a * (2 * np.random.random() - 1))
+            c1, c2, c3 = 2 * np.random.random(), 2 * np.random.random(), 2 * np.random.random()
+
+            x1 = np.array(self.__alpha_wolf.position) - a1 * np.abs(
+                c1 * np.array(self.__alpha_wolf.position) - position
+            )
+            x2 = np.array(self.__beta_wolf.position) - a2 * np.abs(c2 * np.array(self.__beta_wolf.position) - position)
+            x3 = np.array(self.__gamma_wolf.position) - a3 * np.abs(
+                c3 * np.array(self.__gamma_wolf.position) - position
+            )
+            # greedy selection
+            self._population[idx] = self._greedy_select_agent(
+                self._population[idx], self._init_agent((x1 + x2 + x3) / 3)
+            )
+
+        # best 3 solutions will be called as alpha, beta and gaama
+        self.__alpha_wolf, self.__beta_wolf, self.__gamma_wolf = best_agents(self._population, 3)

pyvolutionary/grey_wolf/models.py

@@ -0,0 +1,9 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class GreyWolf(Agent):
+    pass
+
+
+class GreyWolfOptimizationConfig(BaseOptimizationConfig):
+    pass

pyvolutionary/harmony_search/__init__.py

@@ -0,0 +1,2 @@
+from .models import Harmony, HarmonySearchOptimizationConfig
+from .harmony_search_optimization import HarmonySearchOptimization

pyvolutionary/harmony_search/harmony_search_optimization.py

@@ -0,0 +1,64 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import Harmony, HarmonySearchOptimizationConfig
+
+
+class HarmonySearchOptimization(OptimizationAbstract):
+    """
+    Implementation of the Harmony Search Optimization algorithm.
+
+    Args:
+        config (HarmonySearchOptimizationConfig): an instance of HarmonySearchOptimizationConfig class.
+            {parse_obj_doc(HarmonySearchOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] https://doi.org/10.1177/003754970107600201
+    """
+    def __init__(self, config: HarmonySearchOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__fw: np.ndarray | None = None
+        self.__dyn_fw: np.ndarray | None = None
+        self.__fw_damp = 0.9995  # Damp Ratio
+
+    def before_initialization(self):
+        self.__fw = 0.0001 * self._bandwidth()  # Bandwidth
+        self.__dyn_fw = self.__fw
+
+    def __create_new_harmony__(self) -> Harmony:
+        """
+        Create a new harmony. This method is used in the optimization step. It creates a new harmony based on the best
+        solution and the harmony memory. The new harmony is created using the following steps: (1) create a new harmony
+        position, (2) use the harmony memory, (3) pitch adjustment. The pitch adjustment is a random process that can be
+        used to improve the new harmony position.
+        :return: a new harmony.
+        :rtype: Harmony
+        """
+        # Create New Harmony Position
+        pos_new = self._uniform_position()
+        delta = self.__dyn_fw * self._uniform_position()
+
+        # Use Harmony Memory
+        pos_new = np.where(
+            np.random.random(self._task.space_dimension) < self._config.consideration_rate,
+            self._best_agent.position,
+            pos_new
+        )
+
+        # Pitch Adjustment
+        pos_new = np.where(
+            np.random.random(self._task.space_dimension) < self._config.pitch_adjusting_rate, pos_new + delta, pos_new
+        )
+
+        # Create New Harmony
+        return Harmony(**self._init_agent(pos_new).model_dump())
+
+    def optimization_step(self):
+        pop_new = []
+        for index in range(0, self._config.population_size):
+            pop_new.append(self.__create_new_harmony__())
+
+        self.__dyn_fw *= self.__fw_damp
+        self._extend_and_trim_population(pop_new)

pyvolutionary/harmony_search/models.py

@@ -0,0 +1,29 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Harmony(Agent):
+    pass
+
+
+class HarmonySearchOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class for Harmony Search Optimization algorithm.
+        consideration_rate (float): [0, 1), the rate of using harmony memory.\n
+        pitch_adjusting_rate (float): [0, 1), the rate of pitch adjusting.
+    """
+    consideration_rate: float
+    pitch_adjusting_rate: float
+
+    @field_validator("consideration_rate")
+    def correct_consideration_rate(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"consideration_rate\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("pitch_adjusting_rate")
+    def correct_pitch_adjusting_rate(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"pitch_adjusting_rate\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/helpers.py

@@ -0,0 +1,290 @@
+import math
+import random
+import numpy as np
+from pydantic import BaseModel
+
+from .models import T, TaskType
+
+
+def parse_obj_doc(model: BaseModel):
+    """
+    Parse the docstring of a model and return a string containing the name of each field and its type. The docstring
+    must be formatted as follows: "field1 (type1)\nfield2 (type2)\n...". The docstring is used to print the details of
+    the model. The details are printed as follows: "field1 (type1)\nfield2 (type2)\n...".
+    :param model: the model
+    :return: the docstring
+    """
+    details = model.__annotations__
+    doc = [f"{field} ({field_type.__name__})" for field, field_type in details.items()]
+    return "\n".join(doc)
+
+
+def squared_norm(point1: list[float], point2: list[float]):
+    """
+    Calculate the squared distance between two points in the space. This function is used to avoid the square root
+    operation when calculating the distance between two points. The squared distance is calculated as follows:
+    squared_distance = sum((point1 - point2)^2)
+    :param point1: the first point
+    :param point2: the second point
+    :return: the squared distance between the two points
+    :rtype: float
+    """
+    return np.sum((np.array(point1) - np.array(point2))**2)
+
+
+def distance(point1: list[float], point2: list[float]):
+    """
+    Calculate the distance between two points in the space using the Euclidean distance.
+    :param point1: the first point
+    :param point2: the second point
+    :return: the distance between the two points
+    :rtype: float
+    """
+    return np.sqrt(squared_norm(point1, point2))
+
+
+def distances(elements: list | np.ndarray) -> np.ndarray:
+    """
+    Calculate the distance between each element of the provided list
+    :param elements: the list of elements
+    :return: the distance matrix
+    """
+    elements = np.array(elements)
+    a = elements[:, :-1]
+    b = a.reshape(np.prod(a.shape[:-1]), 1, a.shape[-1])
+    return np.sqrt(np.einsum('ijk,ijk->ij', b - a, b - a)).squeeze()
+
+
+def verser(point1: list[float], point2: list[float]) -> np.ndarray:
+    """
+    Calculate the unit vector between two points in the space. The unit vector is calculated as follows:
+    unit_vector = (point1 - point2) / (distance + eps)
+    :param point1: the first point
+    :param point2: the second point
+    :return: the unit vector between the two points
+    :rtype: np.ndarray
+    """
+    dist = distance(point1, point2)
+    return (np.array(point1) - np.array(point2)) / (dist + np.finfo(float).eps)
+
+
+def calculate_fitness(value: float, task_type: TaskType) -> float:
+    """
+    Calculate the fitness of the agent based on its cost value. The fitness is calculated as follows:
+    fitness = 1 / (1 + cost) if cost >= 0 else 1 + abs(cost) (the higher the fitness, the best the agent).
+    :param value: the cost value
+    :param task_type: the type of task (minimization or maximization)
+    :return: the fitness value
+    :rtype: float
+    """
+    value = value if task_type == TaskType.MIN else -value
+    return (1 / (value + 1)) if value >= 0 else (1 + abs(value))
+
+
+def sort_by_cost(population: list[T], reverse: bool = False):
+    """
+    Sort the population by the cost value of each agent (the lower the cost, the best the agent). The sorting is done
+    in-place. If reverse is True, the sorting is done in descending order (the higher the cost, the worst the agent).
+    :param population: the population
+    :param reverse: whether to sort in ascending or descending order
+    """
+    population.sort(key=lambda x: x.cost, reverse=reverse)
+
+
+def sort_and_trim(population: list[T], population_size: int) -> list[T]:
+    """
+    Sort the population according to the cost in ascending order and trim the population to the population size if
+    the population size is exceeded.
+    :param population: the current population
+    :param population_size: the population size
+    :return: the sorted and trimmed population
+    :rtype: list[Agent]
+    """
+    sort_by_cost(population)
+    population = population[:population_size]
+    return population
+
+
+def best_agent(population: list[T], task_type: TaskType | None = TaskType.MIN) -> T:
+    """
+    Get the best agent of the population based on its cost value (the lower the cost, the best the agent).
+    :param population: the population
+    :param task_type: the type of task (minimization or maximization)
+    :return: the best agent
+    :rtype: Agent
+    """
+    (b_agent, ) = best_agents(population, 1, task_type)
+    return b_agent
+
+
+def worst_agent(population: list[T], task_type: TaskType | None = TaskType.MIN) -> T:
+    """
+    Get the worst agent of the population based on its cost value (the higher the cost, the worst the agent).
+    :param population: the population
+    :param task_type: the type of task (minimization or maximization)
+    :return: the worst agent
+    :rtype: Agent
+    """
+    (w_agent, ) = worst_agents(population, 1, task_type)
+    return w_agent
+
+
+def best_agents(population: list[T], n_best: int | None = 3, task_type: TaskType | None = TaskType.MIN) -> list[T]:
+    """
+    Get the best agents of the population based on their cost value (the lower the cost, the best the agent).
+    :param population: the population
+    :param n_best: the number of best agents to return
+    :param task_type: the type of task (minimization or maximization)
+    :return: the best agents
+    :rtype: list[T]
+    """
+    pop = population.copy()
+    sort_by_cost(pop, reverse=(task_type == TaskType.MAX))
+    return pop[:n_best].copy()
+
+
+def worst_agents(population: list[T], n_worst: int | None = 3, task_type: TaskType | None = TaskType.MIN) -> list[T]:
+    """
+    Get the worst agents of the population based on their cost value (the higher the cost, the worst the agent).
+    :param population: the population
+    :param n_worst: the number of worst agents to return
+    :param task_type: the type of task (minimization or maximization)
+    :return: the worst agents
+    :rtype: list[T]
+    """
+    pop = population.copy()
+    sort_by_cost(pop, reverse=(task_type == TaskType.MIN))
+    return pop[:n_worst]
+
+
+def special_agents(
+    population: list[T],
+    n_best: int | None = None,
+    n_worst: int | None = None,
+    task_type: TaskType | None = TaskType.MIN
+) -> tuple[list[T], list[T]]:
+    """
+    Get the best and worst agents of the population based on their cost value (the lower the cost, the best the agent).
+    Either n_best or n_worst must be provided. The best and worst agents are returned as a tuple.
+    :param population: the population
+    :param n_best: the number of best agents to return
+    :param n_worst: the number of worst agents to return
+    :param task_type: the type of task (minimization or maximization)
+    :return: a tuple containing the best and worst agents
+    :rtype: tuple[list[T], list[T]]
+    """
+    if n_best is None and n_worst is None:
+        raise ValueError("Either n_best or n_worst must be provided")
+
+    best = []
+    if n_best is not None:
+        best = best_agents(population, n_best, task_type)
+
+    worst = []
+    if n_worst is not None:
+        worst = worst_agents(population, n_worst, task_type)
+
+    return best, worst
+
+
+def average_fitness(population: list[T]) -> float:
+    """
+    Calculate the average fitness of the population based on the fitness of each agent of the population itself.
+    :param population:
+    :return: the average fitness
+    :rtype: float
+    """
+    return np.average([agent.fitness for agent in population])
+
+
+def get_partner_index(index: int, num_elements: int) -> int:
+    while True:
+        partner_index = random.randint(0, num_elements - 1)
+        if partner_index != index:
+            break
+    return partner_index
+
+
+def roulette_wheel_index(probabilities: np.ndarray) -> int:
+    """
+    Select an index using roulette wheel selection with probabilities as weights of the selection process and return the
+    selected index of the population array of the algorithm instance.
+    :param probabilities: the probabilities of each element of the population
+    :return: the index of the selected element
+    :rtype: int
+    """
+    final_probabilities = np.max(probabilities) - probabilities
+    l = len(probabilities)
+    if all(final_probabilities == 0):
+        return int(np.random.choice(range(0, l)))
+    prob = final_probabilities / np.sum(final_probabilities)
+    return int(np.random.choice(range(0, len(probabilities)), p=prob))
+
+
+def random_selection(p: list | np.ndarray) -> int:
+    """
+    Randomly select an index from the provided probabilities array.
+    :param p: the probabilities array
+    :return: the selected index
+    :rtype: int
+    """
+    r = np.random.random()
+    c = np.cumsum(p)
+    index = [i for i, x in enumerate(c) if r <= x]
+    return index[0]
+
+
+def get_levy_flight_step(
+    beta: float = 1.0,
+    multiplier: float = 0.001,
+    size: int | list | tuple | np.ndarray = None,
+    case: int = 0
+) -> float | list | np.ndarray:
+    """
+    Get the Levy-flight step size
+    :param beta: Should be in range [0, 2]. 0-1: small range --> exploit. 1-2: large range --> explore
+    :param multiplier: default = 0.001
+    :param size: size of levy-flight steps, for example: (3, 2), 5, (4, )
+    :param case: Should be one of these value [0, 1, -1]. 0: return multiplier * s * self.generator.uniform().
+    1: return multiplier * s * self.generator.normal(0, 1). -1: return multiplier * s
+    :return: the step size of Levy-flight trajectory
+    :rtype: float, list, np.ndarray
+    """
+    # u and v are two random variables which follow self.generator.normal distribution
+    # sigma_u : standard deviation of u
+    sigma_u = np.power(math.gamma(1. + beta) * np.sin(np.pi * beta / 2) / (
+        math.gamma((1 + beta) / 2.) * beta * np.power(2., (beta - 1) / 2)
+    ), 1. / beta)
+    size = 1 if size is None else size
+    u = np.random.normal(0, sigma_u ** 2, size)
+    v = np.random.normal(0, 1, size)
+    s = u / np.power(np.abs(v), 1 / beta)
+
+    step = multiplier * s
+    if case == 0:
+        step = multiplier * s * np.random.uniform()
+    elif case == 1:
+        step = multiplier * s * np.random.normal(0, 1)
+    return step[0] if size == 1 else step
+
+
+def generate_group_population(population: list[T], n_groups: int, n_agents: int) -> list[list[T]]:
+    """
+    Generate a list of group population from pop
+    :param population: The current population
+    :param n_groups: The number of groups
+    :param n_agents: The number of agents in each group
+    :return: a list of group population
+    :rtype: list[list[Agent]]
+    """
+    # calculate the groups composed by n_agents
+    groups = []
+    for idx in range(0, n_groups):
+        group = population[idx * n_agents:(idx + 1) * n_agents]
+        groups.append([agent.model_copy() for agent in group])
+
+    # calculate the group composed by the residual agents
+    residual = len(population) % n_groups
+    if residual != 0:
+        groups.append([agent.model_copy() for agent in population[-residual:]])
+    return groups

pyvolutionary/imperialist_competitive/__init__.py

@@ -0,0 +1,2 @@
+from .models import Empire, ImperialistCompetitiveOptimizationConfig
+from .imperialist_competitive_optimization import ImperialistCompetitiveOptimization