pyVolutionary 2.6.1__tar.gz → 2.6.3__tar.gz

{pyvolutionary-2.6.1 → pyvolutionary-2.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyVolutionary
-Version: 2.6.1
+Version: 2.6.3
 Summary: pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems.
 License: MIT
 Author: Matteo Cacciola

{pyvolutionary-2.6.1 → pyvolutionary-2.6.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyVolutionary"
-version = "2.6.1"
+version = "2.6.3"
 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 = "MIT"

{pyvolutionary-2.6.1 → pyvolutionary-2.6.3}/pyvolutionary/abstract.py

@@ -224,13 +224,25 @@ class OptimizationAbstract(ABC, Generic[T]):
 
         self.before_initialization()
 
+        if self._debug:
+            print(f"Starting optimization with {self._config.population_size} agents, "
+                  f"{self._config.max_cycles} cycles and {self._workers} workers")
+            print(f"Task: {self._task.name} - Minmax: {self._task.minmax} - ")
+            print("Initializing population...")
+
         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.after_initialization()
 
+        if self._debug:
+            print("Population initialized")
+
         while True:
+            if self._debug:
+                print(f"Starting cycle {self._current_cycle}...")
+
             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))
@@ -240,7 +252,7 @@ class OptimizationAbstract(ABC, Generic[T]):
             # 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__()
             if self._debug:
-                print(f"Cycle {self._current_cycle} - Best position {self._best_agent.position}, "
+                print(f"Cycle {self._current_cycle} completed - 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:

{pyvolutionary-2.6.1 → pyvolutionary-2.6.3}/pyvolutionary/helpers.py

@@ -145,16 +145,16 @@ def best_agent_formatted(population: list[T], n_params: int, task_type: TaskType
     :return: the best agent
     :rtype: Agent
     """
-    best_agent = best_agent(population, task_type)
+    b_agent = best_agent(population, task_type)
 
-    best_agent_position = np.array(best_agent.position)  # Ensure it's a NumPy array
+    best_agent_position = np.array(b_agent.position)  # Ensure it's a NumPy array
     if len(best_agent_position) % n_params != 0:
         raise ValueError("Length of `best_agent.position` must be a multiple of `n_params`.")
 
     # Reshape the position
-    best_agent.position = best_agent_position.reshape(-1, n_params)
+    b_agent.position = best_agent_position.reshape(-1, n_params)
 
-    return best_agent
+    return b_agent
 
 
 def best_agent_index(population: list[T], task_type: TaskType | None = TaskType.MIN) -> int:
@@ -189,16 +189,16 @@ def worst_agent_formatted(population: list[T], n_params: int, task_type: TaskTyp
     :return: the best agent
     :rtype: Agent
     """
-    worst_agent = worst_agent(population, task_type)
+    w_agent = worst_agent(population, task_type)
 
-    worst_agent_position = np.array(worst_agent.position)  # Ensure it's a NumPy array
+    worst_agent_position = np.array(w_agent.position)  # Ensure it's a NumPy array
     if len(worst_agent_position) % n_params != 0:
         raise ValueError("Length of `worst_agent.position` must be a multiple of `n_params`.")
 
     # Reshape the position
-    worst_agent.position = worst_agent_position.reshape(-1, n_params)
+    w_agent.position = worst_agent_position.reshape(-1, n_params)
 
-    return worst_agent
+    return w_agent
 
 
 def worst_agent_index(population: list[T], task_type: TaskType | None = TaskType.MIN) -> int: