pyVolutionary 2.6.6__tar.gz → 2.7.1__tar.gz

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyVolutionary
-Version: 2.6.6
+Version: 2.7.1
 Summary: pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems.
 License: GPL-3.0-only
 License-File: LICENSE
@@ -331,6 +331,9 @@ As an illustration, consider a TSP scenario involving 5 cities denoted as A, B,
 be denoted by the permutation [A, B, D, E, C], illustrating the order in which the cities are visited. This interpretation
 indicates that the tour initiates at city A, proceeds to city B, then D, E, and ultimately C before looping back to city A.
 
+A `PermutationVariable` spans one dimension per item: the position of an agent holds a key for each item, and the
+permutation is the order of the items by increasing key. Use `transform_solution` to get the permutation of the items.
+
 The following code snippet illustrates how to solve the TSP with the Virus Colony Search Optimization algorithm.
 
 ```python

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/README.md

@@ -304,6 +304,9 @@ As an illustration, consider a TSP scenario involving 5 cities denoted as A, B,
 be denoted by the permutation [A, B, D, E, C], illustrating the order in which the cities are visited. This interpretation
 indicates that the tour initiates at city A, proceeds to city B, then D, E, and ultimately C before looping back to city A.
 
+A `PermutationVariable` spans one dimension per item: the position of an agent holds a key for each item, and the
+permutation is the order of the items by increasing key. Use `transform_solution` to get the permutation of the items.
+
 The following code snippet illustrates how to solve the TSP with the Virus Colony Search Optimization algorithm.
 
 ```python

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyVolutionary"
-version = "2.6.6"
+version = "2.7.1"
 description = "pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems."
 authors = ["Matteo Cacciola <matteo.cacciola@gmail.com>"]
 license = "GPL-3.0-only"

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/abstract.py

@@ -1,3 +1,4 @@
+import random
 from abc import ABC, abstractmethod
 from typing import Generic, Final, Any
 import numpy as np
@@ -50,6 +51,15 @@ class OptimizationAbstract(ABC, Generic[T]):
     def before_initialization(self):
         pass
 
+    def _minimum_population_size(self) -> int:
+        """
+        The minimum size of the population the algorithm can work with (e.g. an algorithm guided by the three best
+        agents needs at least three agents). The algorithms needing more than two agents override it.
+        :return: the minimum population size
+        :rtype: int
+        """
+        return 2
+
     def after_initialization(self):
         pass
 
@@ -66,14 +76,24 @@ class OptimizationAbstract(ABC, Generic[T]):
     def name(self):
         return self.__class__.__name__
 
-    def _fcn(self, x: list[float] | np.ndarray) -> float | list[float]:
+    def _fcn(self, x: list[float] | np.ndarray, corrected: bool = False) -> float | list[float]:
         """
         This method evaluates the objective function.
         :param x: the position to evaluate
+        :param corrected: whether the position has already been corrected by the task
         :return the cost of the position, or the list of costs if the objective function is multi-objective
         :rtype: float | list[float]
         """
-        return self._task.solve(x) if self._task.minmax == TaskType.MIN else -1 * self._task.solve(x)
+        # correcting an already corrected solution is a no-op for the built-in variables: skip it, and pass a copy of
+        # the position, so that the objective function can not alter it
+        if corrected and self._task.idempotent_correction:
+            cost = self._task.objective_function(list(x))
+        else:
+            cost = self._task.solve(x)
+        if self._task.minmax == TaskType.MIN:
+            return cost
+        # multi-objective functions return a list of costs: negate each of them
+        return [-c for c in cost] if isinstance(cost, (list, tuple, np.ndarray)) else -cost
 
     def _init_agent(self, position: list[Any] | np.ndarray | None = None) -> Agent:
         """
@@ -81,7 +101,7 @@ class OptimizationAbstract(ABC, Generic[T]):
         not provided. The other properties of the agent.
         """
         position = self._task.initial_solution(position)
-        cost = self._fcn(position)
+        cost = self._fcn(position, corrected=True)
         n_weights = len(self._task.objective_weights) if self._task.objective_weights is not None else 1
         n_objectives = len(cost) if isinstance(cost, list) else 1
         if n_weights != n_objectives:
@@ -100,10 +120,25 @@ class OptimizationAbstract(ABC, Generic[T]):
 
         # Parallel mode
         with get_pool_executor(self._mode, self._workers) as executor:
-            executors = [executor.submit(self._init_agent) for _ in range(0, n_agents)]
+            if self._mode == ModeSolver.PROCESS:
+                # each worker process inherits a copy of the parent's random state: seed each job independently, or
+                # different workers would generate identical agents
+                seeds = np.random.randint(0, 2**31 - 1, size=n_agents)
+                executors = [executor.submit(self._init_agent_with_seed, int(seed)) for seed in seeds]
+            else:
+                executors = [executor.submit(self._init_agent) for _ in range(0, n_agents)]
             pop = get_pool_results(executors)
         return pop
 
+    def _init_agent_with_seed(self, seed: int) -> Agent:
+        """
+        This method initializes a random agent after seeding the random generators. It is used in process mode.
+        :param seed: the seed of the random generators
+        """
+        np.random.seed(seed)
+        random.seed(seed)
+        return self._init_agent()
+
     def _init_population(self):
         """
         This method initializes the population of the optimization algorithm.
@@ -121,19 +156,11 @@ class OptimizationAbstract(ABC, Generic[T]):
         self._population = sort_by_cost(self._population)
         new_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
-        with get_pool_executor(self._mode, self._workers) as executor:
-            executors = [executor.submit(
-                self._greedy_select_agent, agent, new_population[idx]
-            ) for idx, agent in enumerate(self._population)]
-            self._population = get_pool_results(executors)
+        # the selection is a mere comparison of costs: dispatching it to a pool of workers would be far more
+        # expensive than running it serially
+        self._population = [
+            self._greedy_select_agent(agent, new_population[idx]) for idx, agent in enumerate(self._population)
+        ]
 
     def _greedy_select_agent(self, agent: T, new_agent: T) -> T:
         """
@@ -206,9 +233,24 @@ class OptimizationAbstract(ABC, Generic[T]):
         if not self._config:
             raise ValueError("Invalid configuration")
 
+        minimum_population_size = self._minimum_population_size()
+        if self._config.population_size < minimum_population_size:
+            raise ValueError(
+                f"{self.name} needs a population of at least {minimum_population_size} agents. "
+                f"Got {self._config.population_size}"
+            )
+
         np.random.seed(task.seed)
+        random.seed(task.seed)
         evolution: list[Population] = []
 
+        # reset the state of any previous run, so that the same instance can be used to optimize several times
+        self._current_cycle = 1
+        self._errors = []
+        self._error_diffs = []
+        self._best_agent = None
+        self._worst_agent = None
+
         if workers is not None:
             if workers <= 0:
                 raise ValueError("Invalid number of workers. It must be greater than 0")
@@ -235,6 +277,7 @@ class OptimizationAbstract(ABC, Generic[T]):
         self._init_population()
         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)
+        self._best_agent = self._best_agent.model_copy()
 
         self.after_initialization()
 
@@ -249,7 +292,11 @@ class OptimizationAbstract(ABC, Generic[T]):
             # 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)
+            # the best agent is the best one found so far (the global best): an algorithm may lose it from the
+            # population, but it must neither be lost in the result nor stop guiding the algorithms using it
+            (current_best, ), (self._worst_agent, ) = special_agents(self._population, n_best=1, n_worst=1)
+            if current_best.cost < self._best_agent.cost:
+                self._best_agent = current_best.model_copy()
 
             # stop when the error is below the error criteria or when the maximum number of cycles is reached
             error, fitness, has_to_stop = self.__error_check__()
@@ -280,14 +327,13 @@ class OptimizationAbstract(ABC, Generic[T]):
         # Get the optimal population
         avg_fit = average_fitness(self._population)
         current_error = abs(1 - avg_fit)
-        previous_error = self._errors[-1] if len(self._errors) > 0 else 0
+        # Append the difference between the current error and the previous one to the list of error differences
+        if len(self._errors) > 0:
+            self._error_diffs.append(current_error - self._errors[-1])
 
         # Append the current error to the list of errors
         self._errors.append(current_error)
 
-        # Append the difference between the current error and the previous one to the list of error differences
-        self._error_diffs.append(current_error - previous_error)
-
         return current_error, avg_fit, self.__should_stop__(current_error)
 
     def __should_stop__(self, current_error: float) -> bool:
@@ -301,9 +347,12 @@ class OptimizationAbstract(ABC, Generic[T]):
         has_to_stop = cycle >= max_cycles
 
         # Evaluate the early stopping criteria
+        # (stop when the error has not improved, i.e. decreased, by at least min_delta for patience cycles)
         if early_stopping is not None:
             min_delta, patience = early_stopping.min_delta, early_stopping.patience
-            has_to_stop |= all([diff < 0 and abs(diff) < min_delta for diff in self._error_diffs[-patience:]])
+            has_to_stop |= len(self._error_diffs) >= patience and all(
+                -diff < min_delta for diff in self._error_diffs[-patience:]
+            )
 
         # Stop when the error is below the error criteria
         if fitness_error is not None:

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/african_vulture/african_vulture_optimization.py

@@ -35,13 +35,17 @@ class AfricanVultureOptimization(OptimizationAbstract):
             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
+                A = best_x1 - safe_ratio(best_x1 * position, best_x1 - position ** 2) * F
+                B = best_x2 - safe_ratio(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=dim, case=-1
             )
 
+        def safe_ratio(numerator: np.ndarray, denominator: np.ndarray) -> np.ndarray:
+            # the ratio is zero where the denominator is zero (it was NaN or infinite, e.g. with best_x = position = 0)
+            return np.divide(numerator, denominator, out=np.zeros_like(numerator, dtype=float), where=denominator != 0)
+
         def exploration_position_phase2(rand_pos: np.ndarray, position: np.ndarray) -> np.ndarray:
             if np.random.random() < p3:
                 return (
@@ -66,7 +70,7 @@ class AfricanVultureOptimization(OptimizationAbstract):
             else:  # Exploitation Phase 2
                 pos_new = exploration_position_phase2(rand_pos, position)
             return self._greedy_select_agent(
-                vulture, AfricanVulture(**self._init_agent(pos_new).model_dump())
+                vulture, AfricanVulture(**self._init_agent(pos_new).__dict__)
             )
 
         cycle_ratio = self._current_cycle / self._config.max_cycles

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/ant_colony/ant_colony_optimization.py

@@ -2,7 +2,7 @@ from typing import Any
 import numpy as np
 
 from ..helpers import (
-    roulette_wheel_indexes,
+    roulette_wheel_sampler,
     parse_obj_doc,  # type: ignore
 )
 from ..abstract import OptimizationAbstract
@@ -35,7 +35,7 @@ class AntColonyOptimization(OptimizationAbstract):
             return zeta * np.sum(np.abs(positions - M), axis=0) / (pop_size - 1)
 
         def generate_coordinate(j: int) -> float:
-            rdx, = roulette_wheel_indexes(weights)
+            rdx = select_ant()
             return float(self._population[rdx].position[j] + np.random.normal() * sigmas[rdx, j])
 
         # compute the selection probability of each ant in the population
@@ -51,9 +51,12 @@ class AntColonyOptimization(OptimizationAbstract):
 
         sigmas = np.array([compute_sigma(ant) for ant in self._population])
 
+        # the weights do not change while generating the new ants: build the roulette wheel once
+        select_ant = roulette_wheel_sampler(weights)
+
         # Generate new ants
         new_ants = [Ant(**self._init_agent(
             list(map(generate_coordinate, range(0, self._task.space_dimension)))
-        ).model_dump()) for _ in range(0, self._config.archive_size)]
+        ).__dict__) for _ in range(0, self._config.archive_size)]
 
         self._extend_and_trim_population(new_ants)

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/ant_lion/ant_lion_optimization.py

@@ -42,25 +42,25 @@ class AntLionOptimization(OptimizationAbstract):
                 return 1 + 1000000 * (cycle / max_cycles)
             return 1
 
-        def random_walk_ant_lion(ant_lion_position: np.ndarray) -> np.ndarray:
-            X = np.array([np.cumsum(2 * (np.random.random(pop_size) > 0.5) - 1) for _ in range(0, n_dims)])
+        def random_walk_ant_lion(ant_lion_position: np.ndarray, idx: int) -> np.ndarray:
+            # one row of random steps per dimension (drawn at once, in the same order as row by row)
+            X = np.cumsum(2 * (np.random.random((n_dims, pop_size)) > 0.5) - 1, axis=1)
             # Move the interval of [lb ub] around the ant lion [lb + ant_lion, ub + ant_lion]. Eq 2.8, 2.9
             lb = lower_bounds * (1 if np.random.random() < 0.5 else -1) + ant_lion_position
             ub = upper_bounds * (1 if np.random.random() < 0.5 else -1) + ant_lion_position
             a = np.min(X, axis=1)
             b = np.max(X, axis=1)
-            return (X - np.reshape(a, (n_dims, 1))) * (
-                np.reshape((ub - lb) / (b - a), (n_dims, 1))
-            ) + np.reshape(lb, (n_dims, 1))
+            # only the idx-th step of the walk is used: normalize just that column
+            return (X[:, idx] - a) * ((ub - lb) / (b - a)) + lb
 
         def new_agent(idx: int) -> AntLion:
             roulette_index, = roulette_wheel_indexes(weights)
             # RA is the random walk around the selected ant lion by roulette wheel
-            RA = random_walk_ant_lion(np.array(self._population[roulette_index].position))
+            RA = random_walk_ant_lion(np.array(self._population[roulette_index].position), idx)
             # RE is the random walk around the elite (the best ant lion so far)
-            RE = random_walk_ant_lion(g_best_pos)
-            pos_new = (RA[:, idx] + RE[:, idx]) / 2  # Equation(2.13) in the paper
-            return AntLion(**self._init_agent(pos_new).model_dump())
+            RE = random_walk_ant_lion(g_best_pos, idx)
+            pos_new = (RA + RE) / 2  # Equation(2.13) in the paper
+            return AntLion(**self._init_agent(pos_new).__dict__)
 
         cycle = self._current_cycle
         max_cycles = self._config.max_cycles

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/aquila/aquila_optimization.py

@@ -45,7 +45,7 @@ class AquilaOptimization(OptimizationAbstract):
                 ) if np.random.random() < 0.5 else QF * best_position - (
                     g2 * pos * np.random.random()
                 ) - g2 * levy_step + np.random.random() * g1  # Eq. 13, 14
-            new_agent = Aquila(**self._init_agent(pos_new).model_dump())
+            new_agent = Aquila(**self._init_agent(pos_new).__dict__)
             return self._greedy_select_agent(new_agent, aquila)
 
         current_cycle = self._current_cycle

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/archimede/archimede_optimization.py

@@ -44,7 +44,7 @@ class ArchimedeOptimization(OptimizationAbstract):
         acceleration = self._task.empty_solution() if acceleration is None else (
             acceleration.tolist() if isinstance(acceleration, np.ndarray) else acceleration
         )
-        return Object(**agent.model_dump(), density=density, volume=volume, acceleration=acceleration)
+        return Object(**agent.__dict__, density=density, volume=volume, acceleration=acceleration)
 
     def optimization_step(self):
         def calculate_new_properties(idx: int, obj: Object) -> tuple[np.ndarray, np.ndarray, np.ndarray]:

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/bacterial_foraging/bacterial_foraging_optimization.py

@@ -36,19 +36,21 @@ class BacterialForagingOptimization(OptimizationAbstract):
 
     def _init_agent(self, position: list[Any] | np.ndarray | None = None) -> Cell:
         agent = super()._init_agent(position)
-        return Cell(**agent.model_dump(), local_best=agent.position.copy(), local_cost=agent.cost)
+        return Cell(**agent.__dict__, local_best=agent.position.copy(), local_cost=agent.cost)
 
     def __clean_population__(self):
         """
         Remove duplicates from the population. This method is called after each optimization step.
         """
-        new_set = set()
-        pop = self._population.copy()
-        for idx, obj in enumerate(pop):
-            if pos := tuple(obj.position) in new_set:
-                self._population.pop(idx)
-            else:
-                new_set.add(pos)
+        # keep the first cell of each position
+        seen = set()
+        unique = []
+        for cell in self._population:
+            position = tuple(cell.position)
+            if position not in seen:
+                seen.add(position)
+                unique.append(cell)
+        self._population = unique
 
     def __balance_population__(self):
         """
@@ -63,13 +65,15 @@ class BacterialForagingOptimization(OptimizationAbstract):
         if n_agents < 0:
             self._population += [self._init_agent() for _ in range(0, -n_agents)]
         else:
-            list_idx_removed = np.random.choice(range(0, len(self._population)), n_agents, replace=False)
+            list_idx_removed = np.random.choice(len(self._population), n_agents, replace=False)
             for idx in sorted(list_idx_removed, reverse=True):
                 self._population.pop(idx)
 
     def optimization_step(self):
         def update_step_size(c: Cell) -> float:
-            step_sz = C_s - (C_s - C_e) * c.cost / total_costs
+            # the step size decreases with the share of the cost of the cell (all the costs may be zero)
+            share = c.cost / total_costs if total_costs != 0 else 0
+            step_sz = C_s - (C_s - C_e) * share
             return step_sz / c.nutrients if c.nutrients > 0 else step_sz
 
         def tumble_cell(c: Cell, step_sz: float) -> Cell:
@@ -89,11 +93,11 @@ class BacterialForagingOptimization(OptimizationAbstract):
                     c.nutrients -= 1
                     continue
                 new_cell.nutrients += 1
+                # the personal best is the best position found by the cell so far
+                if c.local_cost < new_cell.cost:
+                    new_cell.local_best = list(c.local_best)
+                    new_cell.local_cost = c.local_cost
                 c = new_cell
-                # update personal best
-                if new_cell.cost < c.local_cost:
-                    c.local_best = new_cell.position.copy()
-                    c.local_cost = new_cell.cost
             return c
 
         C_s, C_e = self.__C_s, self.__C_e
@@ -107,6 +111,7 @@ class BacterialForagingOptimization(OptimizationAbstract):
 
             step_size = update_step_size(cell)
             cell = swim(cell, step_size)
+            self._population[idx] = cell
 
             m = max(self._config.N_split, self._config.N_split + (
                 len(self._population) - self._config.population_size
@@ -124,7 +129,8 @@ class BacterialForagingOptimization(OptimizationAbstract):
                     len(self._population) - self._config.population_size
             ) / self._config.N_adapt)
 
-            if cell.nutrients < nut_min and np.random.random() < self._config.Ped:
+            # eliminate the cell if it is starving, or with probability Ped (elimination-dispersal)
+            if cell.nutrients < nut_min or np.random.random() < self._config.Ped:
                 self._population[idx] = self._init_agent()
 
         # make sure the population does not have duplicates

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/bat/bat_optimization.py

@@ -37,7 +37,7 @@ class BatOptimization(OptimizationAbstract):
         velocity = self._task.correct_solution(velocity if velocity is not None else self._task.empty_solution())
 
         return Bat(
-            **agent.model_dump(),
+            **agent.__dict__,
             velocity=velocity,
             loudness=loudness if loudness is not None else np.random.uniform(*self._config.loudness),
             pulse_rate=pulse_rate if pulse_rate is not None else np.random.uniform(*self._config.pulse_rate),

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/battle_royale/battle_royale_optimization.py

@@ -31,7 +31,7 @@ class BattleRoyaleOptimization(OptimizationAbstract):
 
     def _init_agent(self, position: list[Any] | np.ndarray | None = None, damage: int | None = None) -> Soldier:
         agent = super()._init_agent(position=position)
-        soldier = Soldier(**agent.model_dump())
+        soldier = Soldier(**agent.__dict__)
         if damage is not None:
             soldier.damage = damage
         return soldier

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/bee_colony/bee_colony_optimization.py

@@ -2,6 +2,7 @@ from typing import Any
 import numpy as np
 
 from ..helpers import (
+    normalize_costs,
     get_partner_index,
     roulette_wheel_indexes,
     parse_obj_doc,  # type: ignore
@@ -33,12 +34,18 @@ class BeeColonyOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = BeeColonyOptimizationConfig(**parameters)
 
-    def before_initialization(self):
-        self._config.population_size = int(self._config.population_size / 2)
+    def _minimum_population_size(self) -> int:
+        # half of the colony are food sources, and a food source needs a partner
+        return 4
+
+    def _init_population(self):
+        # half of the colony are employed bees, each one bound to a food source: the population is made of the food
+        # sources (the configuration is not altered, so that it can be reused for further optimizations)
+        self._population = self._generate_agents(int(self._config.population_size / 2))
 
     def _init_agent(self, position: list[float] | np.ndarray | None = None) -> Bee:
         agent = super()._init_agent(position)
-        return Bee(**agent.model_dump())
+        return Bee(**agent.__dict__)
 
     def _greedy_select_agent(self, agent: Bee, new_agent: Bee) -> Bee:
         """
@@ -77,7 +84,7 @@ class BeeColonyOptimization(OptimizationAbstract):
             selected_bee = self._population[jdx]
             return food_source_dance(idx, selected_bee)
 
-        population_size = self._config.population_size
+        population_size = len(self._population)
         dims = self._task.space_dimension
         phi = np.random.uniform(low=-1, high=1, size=dims)
 
@@ -87,7 +94,7 @@ class BeeColonyOptimization(OptimizationAbstract):
         # based to probability, generate a neighbour point and evaluate again some food sources
         # same food source can be evaluated multiple times
         employed_costs = np.array([agent.cost for agent in self._population])
-        probabilities = employed_costs / np.sum(employed_costs)
+        probabilities = normalize_costs(employed_costs)
         self._population = [send_onlooker_bees(idx) for idx in range(0, population_size)]
 
         # abandon the food sources which have not been improved after a predefined number of trials; it means to send

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/biogeography_based/biogeography_based_optimization.py

@@ -2,6 +2,7 @@ from typing import Any
 import numpy as np
 
 from ..helpers import (
+    normalize_costs,
     best_agents,
     roulette_wheel_indexes,
     parse_obj_doc,  # type: ignore
@@ -45,7 +46,7 @@ class BiogeographyBasedOptimization(OptimizationAbstract):
             pos_new = np.where(condition, self._population[idx_selected].position, population.position)
             # Mutation
             pos_new = np.where(np.random.random(n_dims) < p_m, self._task.empty_solution(), pos_new)
-            agent_new = Population(**self._init_agent(pos_new).model_dump())
+            agent_new = Population(**self._init_agent(pos_new).__dict__)
             return self._greedy_select_agent(population, agent_new)
 
         n_dims = self._task.space_dimension
@@ -55,8 +56,7 @@ class BiogeographyBasedOptimization(OptimizationAbstract):
         pop_elites = best_agents(self._population, n_best=self._config.n_elites)
 
         # pick a position from which to emigrate (roulette wheel selection)
-        costs = np.array([agent.cost for agent in self._population])
-        costs /= np.sum(costs)
+        costs = normalize_costs(np.array([agent.cost for agent in self._population]))
 
         self._population = [evolve(idx, agent) for idx, agent in enumerate(self._population)]
 

{pyvolutionary-2.6.6 → pyvolutionary-2.7.1}/pyvolutionary/brain_storm/brain_storm_optimization.py

@@ -4,6 +4,7 @@ import numpy as np
 
 from ..helpers import (
     find_centers,
+    split_in_clusters,
     parse_obj_doc,  # type: ignore
 )
 from ..abstract import OptimizationAbstract
@@ -25,40 +26,39 @@ class BrainStormOptimization(OptimizationAbstract):
     """
     def __init__(self, config: BrainStormOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
-        self.__m_solution: int | None = None
         self.__clusters: list[list[Person]] = []
         self.__centers: list[Person] = []
 
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = BrainStormOptimizationConfig(**parameters)
 
-    def before_initialization(self):
-        self.__m_solution = int(self._config.population_size / self._config.m_clusters)
-
     def after_initialization(self):
-        self.__clusters = self._generate_group_population(self._config.m_clusters, self.__m_solution, False)
+        # every agent belongs to a cluster, also when the population size is not a multiple of m_clusters
+        self.__clusters = split_in_clusters(self._population, self._config.m_clusters)
         self.__centers: list[Person] = find_centers(self.__clusters)
 
     def optimization_step(self):
         def evolve(idx: int) -> tuple[Person, int, int]:
-            cluster_id = int(idx / m_solution)
-            location_id = int(idx % m_solution)
+            cluster_id, location_id = locations[idx]
             if np.random.uniform() < p2:  # p_6b
-                rand_idx = np.random.randint(0, m_solution)
+                rand_idx = np.random.randint(0, len(self.__clusters[cluster_id]))
                 pos_new = np.array(self.__clusters[cluster_id][rand_idx].position) + np.random.normal(0, 1, n_dims)
                 if np.random.uniform() < p3:  # p_6i
-                    cluster_id = np.random.randint(0, m_clusters)
-                    pos_new = np.array(self.__centers[cluster_id].position) + epsilon * np.random.normal(0, 1, n_dims)
+                    # the new idea comes from the center of a random cluster, and competes with the agent idx
+                    center_id = np.random.randint(0, m_clusters)
+                    pos_new = np.array(self.__centers[center_id].position) + epsilon * np.random.normal(0, 1, n_dims)
             else:
-                id1, id2 = np.random.choice(range(0, m_clusters), 2, replace=False)
+                id1, id2 = np.random.choice(m_clusters, 2, replace=False)
                 pos_new = 0.5 * (
                     np.array(self.__centers[id1].position) + np.array(self.__centers[id2].position)
                 ) + epsilon * np.random.normal(0, 1, n_dims)
                 if np.random.uniform() >= p4:
-                    pos_rand_id1 = np.array(self.__clusters[id1][np.random.randint(0, m_solution)].position)
-                    pos_rand_id2 = np.array(self.__clusters[id2][np.random.randint(0, m_solution)].position)
+                    cluster1 = self.__clusters[id1]
+                    pos_rand_id1 = np.array(cluster1[np.random.randint(0, len(cluster1))].position)
+                    cluster2 = self.__clusters[id2]
+                    pos_rand_id2 = np.array(cluster2[np.random.randint(0, len(cluster2))].position)
                     pos_new = 0.5 * (pos_rand_id1 + pos_rand_id2) + epsilon * np.random.normal(0, 1, n_dims)
-            agent = Person(**self._init_agent(pos_new).model_dump())
+            agent = Person(**self._init_agent(pos_new).__dict__)
             return agent, cluster_id, location_id
 
         epoch = self._current_cycle
@@ -68,16 +68,17 @@ class BrainStormOptimization(OptimizationAbstract):
         epsilon = np.random.uniform() * (1 / (1 + np.exp(-x)))
 
         p1, p2, p3, p4 = self._config.p1, self._config.p2, self._config.p3, self._config.p4
-        m_solution = self.__m_solution
+        # the (cluster, location) of each agent, cluster by cluster
+        locations = [(c_id, l_id) for c_id, cluster in enumerate(self.__clusters) for l_id in range(0, len(cluster))]
 
         n_dims = self._task.space_dimension
-        m_clusters = self._config.m_clusters
+        m_clusters = len(self.__clusters)
 
         epsilon = 1. - 1. * epoch / epochs
         if np.random.uniform() < p1:
-            self.__centers[np.random.randint(0, m_clusters)] = Person(**self._init_agent().model_dump())
+            self.__centers[np.random.randint(0, m_clusters)] = Person(**self._init_agent().__dict__)
 
-        new_agents, cluster_ids, location_ids = zip(*[evolve(idx) for idx in range(0, self._config.population_size)])
+        new_agents, cluster_ids, location_ids = zip(*[evolve(idx) for idx in range(0, len(locations))])
         for cl_id, loc_id, new_agent in zip(cluster_ids, location_ids, new_agents):
             self.__clusters[cl_id][loc_id] = self._greedy_select_agent(self.__clusters[cl_id][loc_id], new_agent)