pyVolutionary 2.5.0__tar.gz → 2.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyVolutionary
-Version: 2.5.0
+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
@@ -516,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)
 
@@ -547,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.5.0 → 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.5.0 → pyvolutionary-2.5.1}/pyproject.toml

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

{pyvolutionary-2.5.0 → 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.5.0 → 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.5.0/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.5.0 → 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):