pyVolutionary 2.4.2__tar.gz → 2.5.1__tar.gz

{pyvolutionary-2.4.2 → pyvolutionary-2.5.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: pyVolutionary
-Version: 2.4.2
+Version: 2.5.1
 Summary: pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems.
 Home-page: https://github.com/matteocacciola/pyvolutionary
 License: MIT
 Author: Matteo Cacciola
 Author-email: matteo.cacciola@gmail.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.10
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -14,13 +14,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
-Requires-Dist: matplotlib (>=3.8.1,<4.0.0)
-Requires-Dist: numpy (>=1.26.1,<2.0.0)
-Requires-Dist: opfunu (>=1.0.1,<2.0.0)
+Requires-Dist: numpy (>=2.1.1,<3.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
-Requires-Dist: pydantic (>=2.4.2,<3.0.0)
+Requires-Dist: pydantic (>=2.9.0,<3.0.0)
 Requires-Dist: scipy (>=1.12.0,<2.0.0)
-Requires-Dist: sphynx (>=0.0.3,<0.0.4)
 Project-URL: Repository, https://github.com/matteocacciola/pyvolutionary
 Description-Content-Type: text/markdown
 
@@ -519,15 +516,15 @@ Once you created your new classes, you can run the algorithm by calling the `opt
 ## Utilities
 **pyVolutionary** provides a set of utilities to facilitate the use of the library.
 
-### GridSearchCV Hyper-parameter tuning
-**pyVolutionary** provides a `GridSearchCV` class to perform hyperparameter tuning of a model. The class is similar to
-the one provided by [scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html),
-but it uses the algorithms implemented in the library to perform the search. The class can be used as follows:
+### HyperTuner Hyper-parameter tuning
+**pyVolutionary** provides a `HyperTuner` class to perform hyperparameter tuning of a model, by means of the algorithms
+implemented in the library. The class can be used to replace the `GridSearchCV` of
+[scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html):
 
 ```python
 from opfunu.cec_based.cec2017 import F52017
 
-from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, GridSearchCV
+from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, HyperTuner
 
 f1 = F52017(30, f_bias=0)
 
@@ -550,9 +547,8 @@ params_bbo_grid = {
     "p_m": [0.01, 0.02, 0.05]
 }
 
-
 model = BiogeographyBasedOptimization()
-tuner = GridSearchCV(model, params_bbo_grid)
+tuner = HyperTuner(model, params_bbo_grid)
 
 tuner.execute(task=task)
 

{pyvolutionary-2.4.2 → pyvolutionary-2.5.1}/README.md

@@ -493,15 +493,15 @@ Once you created your new classes, you can run the algorithm by calling the `opt
 ## Utilities
 **pyVolutionary** provides a set of utilities to facilitate the use of the library.
 
-### GridSearchCV Hyper-parameter tuning
-**pyVolutionary** provides a `GridSearchCV` class to perform hyperparameter tuning of a model. The class is similar to
-the one provided by [scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html),
-but it uses the algorithms implemented in the library to perform the search. The class can be used as follows:
+### HyperTuner Hyper-parameter tuning
+**pyVolutionary** provides a `HyperTuner` class to perform hyperparameter tuning of a model, by means of the algorithms
+implemented in the library. The class can be used to replace the `GridSearchCV` of
+[scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html):
 
 ```python
 from opfunu.cec_based.cec2017 import F52017
 
-from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, GridSearchCV
+from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, HyperTuner
 
 f1 = F52017(30, f_bias=0)
 
@@ -524,9 +524,8 @@ params_bbo_grid = {
     "p_m": [0.01, 0.02, 0.05]
 }
 
-
 model = BiogeographyBasedOptimization()
-tuner = GridSearchCV(model, params_bbo_grid)
+tuner = HyperTuner(model, params_bbo_grid)
 
 tuner.execute(task=task)
 

{pyvolutionary-2.4.2 → pyvolutionary-2.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyVolutionary"
-version = "2.4.2"
+version = "2.5.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 = "MIT"
@@ -15,13 +15,10 @@ classifiers = [
 
 
 [tool.poetry.dependencies]
-python = ">=3.10,<3.13"
-pydantic = "^2.4.2"
-numpy = "^1.26.1"
-matplotlib = "^3.8.1"
-sphynx = "^0.0.3"
+python = ">=3.10"
+pydantic = "^2.9.0"
+numpy = "^2.1.1"
 pandas = "^2.2.0"
-opfunu = "^1.0.1"
 scipy = "^1.12.0"
 
 
@@ -39,6 +36,15 @@ sphinx = "^7.2.6"
 sphinx-rtd-theme = "^1.3.0"
 myst-parser = "^2.0.0"
 
+
+[tool.poetry.group.demo.dependencies]
+matplotlib = "^3.7.5"
+
+
+[tool.poetry.group.examples.dependencies]
+opfunu = "^1.0.1"
+
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

{pyvolutionary-2.4.2 → pyvolutionary-2.5.1}/pyvolutionary/__init__.py

@@ -80,21 +80,22 @@ from .whales import *
 from .wildebeest_herd import *
 from .wind_driven import *
 from .zebra import *
-from .gridsearchcv import GridSearchCV
+from .hypertuner import HyperTuner
 from .enums import TaskType
 from .multitask import Multitask
 from .models import (
+    Agent,
+    EarlyStopping,
     OptimizationResult,
     Population,
-    Agent,
     Task,
+    BinaryVariable,
     ContinuousVariable,
     ContinuousMultiVariable,
     DiscreteVariable,
     DiscreteMultiVariable,
-    PermutationVariable,
     MultiObjectiveVariable,
-    BinaryVariable,
+    PermutationVariable,
 )
 from .helpers import best_agent, worst_agent, best_agents, worst_agents, special_agents, get_levy_flight_step
 from .utils import agent_trend, best_agent_trend, agent_position, best_agent_position

{pyvolutionary-2.4.2 → pyvolutionary-2.5.1}/pyvolutionary/abstract.py

@@ -36,6 +36,8 @@ class OptimizationAbstract(ABC, Generic[T]):
         self._best_agent: T | None = None
         self._worst_agent: T | None = None
         self._current_cycle = 1
+        self._errors = []
+        self._error_diffs = []
 
     @abstractmethod
     def optimization_step(self):
@@ -228,7 +230,6 @@ class OptimizationAbstract(ABC, Generic[T]):
 
         self.after_initialization()
 
-        errors: list[float] = []
         while True:
             self.optimization_step()
             # append the current population to the evolution, being sure that costs and fitness are updated
@@ -237,8 +238,7 @@ class OptimizationAbstract(ABC, Generic[T]):
             (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)
+            error, fitness, has_to_stop = self.__error_check__()
             if self._debug:
                 print(f"Cycle {self._current_cycle} - Best position {self._best_agent.position}, "
                       f"cost {self._best_agent.cost if task.minmax == TaskType.MIN else -self._best_agent.cost} - "
@@ -253,10 +253,10 @@ class OptimizationAbstract(ABC, Generic[T]):
                   f"Error criteria reached - Fitness error: {error}")
 
         return OptimizationResult(
-            evolution=evolution, rates=errors, best_solution=self._best_agent, task_type=task.minmax
+            evolution=evolution, rates=self._errors, best_solution=self._best_agent, task_type=task.minmax
         )
 
-    def __should_stop__(self) -> tuple[float, float, bool]:
+    def __error_check__(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
@@ -264,15 +264,36 @@ class OptimizationAbstract(ABC, Generic[T]):
         :rtype: tuple[float, float, bool]
         """
         # Get the optimal population
-        fitness_error = self._config.fitness_error
         avg_fit = average_fitness(self._population)
-        cycle = self._current_cycle
+        current_error = abs(1 - avg_fit)
+        previous_error = self._errors[-1] if len(self._errors) > 0 else 0
+
+        # 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:
+        fitness_error = self._config.fitness_error
         max_cycles = self._config.max_cycles
+        early_stopping = self._config.early_stopping
 
-        current_error = abs(1 - avg_fit)
+        cycle = self._current_cycle
+
+        # Stop when the maximum number of cycles is reached
+        has_to_stop = cycle >= max_cycles
+
+        # Evaluate the early stopping criteria
+        if early_stopping is not None:
+            min_delta, patience = early_stopping.min_delta, early_stopping.patience
+            print(min_delta, patience, self._error_diffs[-patience:])
+            has_to_stop |= all([diff < 0 and abs(diff) < min_delta for diff in self._error_diffs[-patience:]])
 
-        # 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
+        # Stop when the error is below the error criteria
+        if fitness_error is not None:
+            has_to_stop |= current_error <= fitness_error
 
-        return current_error, avg_fit, current_error <= fitness_error or cycle >= max_cycles
+        return has_to_stop

pyvolutionary-2.4.2/pyvolutionary/gridsearchcv.py → pyvolutionary-2.5.1/pyvolutionary/hypertuner.py

@@ -25,7 +25,7 @@ class ParameterGrid:
 
     Parameters
     ----------
-    param_grid : dict of str to sequence, or sequence of such
+    param_grid: dict of str to sequence, or sequence of such
         The parameter grid to explore, as a dictionary mapping estimator
         parameters to sequences of allowed values.
 
@@ -37,8 +37,7 @@ class ParameterGrid:
 
     See Also
     --------
-    GridSearchCV : Uses :class:`ParameterGrid` to perform a full parallelized
-        parameter search.
+    HyperTuner: Uses :class:`ParameterGrid` to perform a full parallelized parameter search.
     """
 
     def __init__(self, param_grid):
@@ -148,9 +147,9 @@ class ParameterGrid:
         raise IndexError("ParameterGrid index out of range")
 
 
-class GridSearchCV:
+class HyperTuner:
     """
-    GridSearchCV utility.
+    HyperTuner utility.
 
     This is a feature that enables the tuning of hyperparameters for an algorithm.
     It also supports exporting results in various formats, such as Pandas DataFrame, JSON, and CSV.

{pyvolutionary-2.4.2 → pyvolutionary-2.5.1}/pyvolutionary/models.py

@@ -68,10 +68,22 @@ class LabelEncoder:
         return [self.__unique_labels__[i] if i in self.__label_to_index__.values() else "unknown" for i in y]
 
 
+class EarlyStopping(BaseModel):
+    patience: int | None = 1
+    min_delta: float | None = 1e-4
+
+    @field_validator("patience")
+    def validate_patience(cls, v):
+        if v is not None and v < 1:
+            raise ValueError(f"\"patience\" must be greater than or equal to one. Got {v}")
+        return v
+
+
 class BaseOptimizationConfig(BaseModel):
     population_size: int
     fitness_error: float | None = 0.1
     max_cycles: int
+    early_stopping: EarlyStopping | None = None
 
 
 class Agent(BaseModel):

{pyvolutionary-2.4.2 → pyvolutionary-2.5.1}/pyvolutionary/utils.py

@@ -1,64 +1,5 @@
-import os
-import numpy as np
-from matplotlib import pyplot as plt, animation
-
 from .helpers import sort_by_cost
-from .models import OptimizationResult, Population
-
-
-def plot(
-    fitness_function: callable,
-    pos_min: float,
-    pos_max: float,
-    evolution: list[Population],
-):
-    # Plotting preparation
-    x = np.linspace(pos_min, pos_max, 80)
-    y = np.linspace(pos_min, pos_max, 80)
-    X, Y = np.meshgrid(x, y)
-    Z = fitness_function([X, Y])
-
-    # Plot the surface.
-    # fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
-    # ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, linewidth=0, antialiased=False)
-    # Plot the wireframe
-    fig = plt.figure(figsize=(10, 10))
-    ax = fig.add_subplot(111, projection='3d')
-    ax.plot_wireframe(X, Y, Z, color='r', linewidth=0.2)
-    ax.set_xlabel('x')
-    ax.set_ylabel('y')
-    ax.set_zlabel('z')
-
-    # Animation image placeholder
-    images = []
-
-    # Add plot for each generation
-    for generation in evolution:
-        x = np.zeros(len(generation.agents))
-        y = np.zeros(len(generation.agents))
-        z = np.zeros(len(generation.agents))
-        for i, agent in enumerate(generation.agents):
-            x[i], y[i] = agent.position
-            z[i] = agent.cost
-        image = ax.scatter3D(x, y, z, c='b')
-        images.append([image])
-
-    return fig, images
-
-
-def animate(
-    fitness_function: callable,
-    optimization_result: OptimizationResult,
-    pos_min: float,
-    pos_max: float,
-    filename: str
-):
-    current_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Generate and save the animation image
-    figure, images = plot(fitness_function, pos_min, pos_max, optimization_result.evolution)
-    animated_image = animation.ArtistAnimation(figure, images)
-    animated_image.save(os.path.join(current_dir, "..", filename), writer='pillow')
+from .models import OptimizationResult
 
 
 def agent_trend(result: OptimizationResult, idx: int, iters: list[int] | None = None) -> list[float]: