pyVolutionary 2.2.0__tar.gz → 2.4.0__tar.gz

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyVolutionary
-Version: 2.2.0
+Version: 2.4.0
 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
@@ -13,12 +13,15 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Requires-Dist: coverage (>=7.3.2,<8.0.0)
 Requires-Dist: install (>=1.3.5,<2.0.0)
 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: pandas (>=2.2.0,<3.0.0)
 Requires-Dist: pydantic (>=2.4.2,<3.0.0)
 Requires-Dist: sphynx (>=0.0.3,<0.0.4)
 Project-URL: Repository, https://github.com/matteocacciola/pyvolutionary
@@ -90,13 +93,15 @@ continuous and discrete variables. In order to do so, you need to define a `Task
 `Task` class of the library. The list of variables in the problem must be specified in the constructor of the class
 inheriting from `Task`. The following table describes the types of variables currently implemented in the library.
 
-| Variable type   | Class name               | Description                                                    | Example                                                                            |
-|-----------------|--------------------------|----------------------------------------------------------------|------------------------------------------------------------------------------------|
-| Continuous      | `ContinuousVariable`     | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`             |
-| Discrete        | `DiscreteVariable`       | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`   |
-| Permutation     | `PermutationVariable`    | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`     |
-| Binary          | `BinaryVariable`         | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                              |
-| Multi-objective | `MultiObjectiveVariable` | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))` |
+| Variable type    | Class name                | Description                                                    | Example                                                                                                  |
+|------------------|---------------------------|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
+| Continuous       | `ContinuousVariable`      | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`                                   |
+| Continuous (set) | `ContinuousMultiVariable` | A set of continuous variables                                  | `ContinuousMultiVariable(name="x0", lower_bounds=[-100.0, -200.0], upper_bounds=[100.0, 50.0])`          |
+| Discrete         | `DiscreteVariable`        | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`                         |
+| Discrete (set)   | `DiscreteMultiVariable`   | A set of discrete variables                                    | `DiscreteMultiVariable(choices=[[0.1, 10, 100], ["scale", "auto", 0.01, 0.1, 0.5, 1.0]], name="params")` |
+| Permutation      | `PermutationVariable`     | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`                           |
+| Binary           | `BinaryVariable`          | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                                                    |
+| Multi-objective  | `MultiObjectiveVariable`  | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))`                       |
 
 An example of a custom `Task` class is the following:
 
@@ -173,7 +178,7 @@ task = Sphere(
 For example, let us inspect how you can solve the continuous _sphere_ problem with the Particle Swarm Optimization algorithm.
 
 ```python
-from pyvolutionary import ContinuousVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
+from pyvolutionary import ContinuousMultiVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
 
 # Define the problem, you can replace the following class with your custom problem to optimize
 class Sphere(Task):
@@ -185,22 +190,14 @@ class Sphere(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
-population = 200
-dimension = 2
-position_min = -100.0
-position_max = 100.0
-generation = 400
-fitness_error = 10e-4
 task = Sphere(
-    variables=[ContinuousVariable(
-        name=f"x{i}", lower_bound=position_min, upper_bound=position_max
-    ) for i in range(dimension)],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=[-100.0, -100.0], upper_bound=[100.0, 100.0])],
 )
 
 configuration = ParticleSwarmOptimizationConfig(
-    population_size=population,
-    fitness_error=fitness_error,
-    max_cycles=generation,
+    population_size=200,
+    fitness_error=10e-4,
+    max_cycles=400,
     c1=0.1,
     c2=0.1,
     w=[0.35, 1],
@@ -435,7 +432,7 @@ implemented in the library):
 
 ```python
 import numpy as np
-from pyvolutionary import Task, ContinuousVariable, AntLionOptimization, AntLionOptimizationConfig
+from pyvolutionary import Task, ContinuousMultiVariable, AntLionOptimization, AntLionOptimizationConfig
 
 ## Link: https://onlinelibrary.wiley.com/doi/pdf/10.1002/9781119136507.app2
 class ConstrainedBenchmark(Task):
@@ -479,12 +476,10 @@ class ConstrainedBenchmark(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
+lower_bounds = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+upper_bounds = [1, 1, 1, 1, 1, 1, 1, 1, 1, 100, 100, 100, 1]
 task = ConstrainedBenchmark(
-    variables=(
-        [ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=1) for i in range(9)] + [
-            ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=100) for i in range(9, 12)
-        ] + [ContinuousVariable(name=f"x12", lower_bound=0, upper_bound=1)]
-    )
+    variables=([ContinuousMultiVariable(name="x", lower_bounds=lower_bounds, upper_bounds=upper_bounds)])
 )
 
 configuration = AntLionOptimizationConfig(population_size=200, fitness_error=10e-4, max_cycles=400)
@@ -522,6 +517,135 @@ 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:
+
+```python
+from opfunu.cec_based.cec2017 import F52017
+
+from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, GridSearchCV
+
+f1 = F52017(30, f_bias=0)
+
+
+class Problem(Task):
+    # Link: https://en.wikipedia.org/wiki/Test_functions_for_optimization
+    def objective_function(self, solution):
+        return f1.evaluate(solution)
+
+
+# Define the task with the bounds and the configuration of the optimizer
+task = Problem(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
+)
+
+params_bbo_grid = {
+    "max_cycles": [10, 20, 30, 40],
+    "population_size": [50, 100, 150],
+    "n_elites": [3, 4, 5, 6],
+    "p_m": [0.01, 0.02, 0.05]
+}
+
+
+model = BiogeographyBasedOptimization()
+tuner = GridSearchCV(model, params_bbo_grid)
+
+tuner.execute(task=task)
+
+print(f"Best row {tuner.best_row}")
+print(f"Best score {tuner.best_score}")
+print(f"Best parameters {tuner.best_parameters}")
+
+best_result = tuner.resolve()
+print(f"Best solution after tuning {best_result.best_solution}")
+
+tuner.export_results("csv")
+tuner.export_results("dataframe")
+tuner.export_results("json")
+```
+
+### Multitasking
+**pyVolutionary** provides a `Multitask` class to perform multitasking optimization. The class can become very precious
+when you need to optimize multiple tasks with multiple algorithms in parallel. In case, for instance, of multiple tasks
+with the same algorithm, you can use the `Multitask` class to run the optimization in parallel. Furthermore, the
+`Multitask` class can be used to run multiple tasks with different algorithms in parallel. Here is an example of how
+to use the `Multitask` class:
+
+```python
+from opfunu.cec_based.cec2017 import F52017, F102017, F292017
+
+from pyvolutionary import (
+    ContinuousMultiVariable,
+    Task,
+    NuclearReactionOptimization,
+    Multitask,
+    NuclearReactionOptimizationConfig,
+    MountainGazelleOptimization,
+    MountainGazelleOptimizationConfig,
+    GrasshopperOptimization,
+    GrasshopperOptimizationConfig,
+    GizaPyramidConstructionOptimization,
+    GizaPyramidConstructionOptimizationConfig,
+)
+
+f1 = F52017(30, f_bias=0)
+f2 = F102017(30, f_bias=0)
+f3 = F292017(30, f_bias=0)
+
+
+class Problem1(Task):
+    def objective_function(self, solution):
+        return f1.evaluate(solution)
+
+
+class Problem2(Task):
+    def objective_function(self, solution):
+        return f3.evaluate(solution)
+
+
+class Problem3(Task):
+    def objective_function(self, solution):
+        return f1.evaluate(solution)
+
+
+task1 = Problem1(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
+)
+task2 = Problem2(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f2.lb, upper_bounds=f2.ub)],
+)
+task3 = Problem3(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f3.lb, upper_bounds=f3.ub)],
+)
+
+model1 = NuclearReactionOptimization(
+    config=NuclearReactionOptimizationConfig(max_cycles=10000, population_size=50)
+)
+model2 = MountainGazelleOptimization(
+    config=MountainGazelleOptimizationConfig(max_cycles=10000, population_size=50)
+)
+model3 = GrasshopperOptimization(
+    config=GrasshopperOptimizationConfig(max_cycles=10000, population_size=50, c_min=0.00004, c_max=2.0,)
+)
+model4 = GizaPyramidConstructionOptimization(
+    config=GizaPyramidConstructionOptimizationConfig(
+        max_cycles=10000, population_size=50, theta=14, friction=[1, 10], prob_substitution=0.5,
+    )
+)
+
+multitask = Multitask(
+    algorithms=(model1, model2, model3, model4), tasks=(task1, task2, task3), modes=("thread", ), n_workers=4
+)
+
+multitask.execute(n_trials=2, n_jobs=2, debug=True)
+
+multitask.export_results("csv")
+multitask.export_results("dataframe")
+multitask.export_results("json")
+```
+
 ### Agent characteristics
 The characteristics of an agent can be extracted by using two functions:
 - `agent_trend`: it returns the trend of the agent at each iteration

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/README.md

@@ -64,13 +64,15 @@ continuous and discrete variables. In order to do so, you need to define a `Task
 `Task` class of the library. The list of variables in the problem must be specified in the constructor of the class
 inheriting from `Task`. The following table describes the types of variables currently implemented in the library.
 
-| Variable type   | Class name               | Description                                                    | Example                                                                            |
-|-----------------|--------------------------|----------------------------------------------------------------|------------------------------------------------------------------------------------|
-| Continuous      | `ContinuousVariable`     | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`             |
-| Discrete        | `DiscreteVariable`       | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`   |
-| Permutation     | `PermutationVariable`    | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`     |
-| Binary          | `BinaryVariable`         | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                              |
-| Multi-objective | `MultiObjectiveVariable` | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))` |
+| Variable type    | Class name                | Description                                                    | Example                                                                                                  |
+|------------------|---------------------------|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
+| Continuous       | `ContinuousVariable`      | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`                                   |
+| Continuous (set) | `ContinuousMultiVariable` | A set of continuous variables                                  | `ContinuousMultiVariable(name="x0", lower_bounds=[-100.0, -200.0], upper_bounds=[100.0, 50.0])`          |
+| Discrete         | `DiscreteVariable`        | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`                         |
+| Discrete (set)   | `DiscreteMultiVariable`   | A set of discrete variables                                    | `DiscreteMultiVariable(choices=[[0.1, 10, 100], ["scale", "auto", 0.01, 0.1, 0.5, 1.0]], name="params")` |
+| Permutation      | `PermutationVariable`     | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`                           |
+| Binary           | `BinaryVariable`          | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                                                    |
+| Multi-objective  | `MultiObjectiveVariable`  | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))`                       |
 
 An example of a custom `Task` class is the following:
 
@@ -147,7 +149,7 @@ task = Sphere(
 For example, let us inspect how you can solve the continuous _sphere_ problem with the Particle Swarm Optimization algorithm.
 
 ```python
-from pyvolutionary import ContinuousVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
+from pyvolutionary import ContinuousMultiVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
 
 # Define the problem, you can replace the following class with your custom problem to optimize
 class Sphere(Task):
@@ -159,22 +161,14 @@ class Sphere(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
-population = 200
-dimension = 2
-position_min = -100.0
-position_max = 100.0
-generation = 400
-fitness_error = 10e-4
 task = Sphere(
-    variables=[ContinuousVariable(
-        name=f"x{i}", lower_bound=position_min, upper_bound=position_max
-    ) for i in range(dimension)],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=[-100.0, -100.0], upper_bound=[100.0, 100.0])],
 )
 
 configuration = ParticleSwarmOptimizationConfig(
-    population_size=population,
-    fitness_error=fitness_error,
-    max_cycles=generation,
+    population_size=200,
+    fitness_error=10e-4,
+    max_cycles=400,
     c1=0.1,
     c2=0.1,
     w=[0.35, 1],
@@ -409,7 +403,7 @@ implemented in the library):
 
 ```python
 import numpy as np
-from pyvolutionary import Task, ContinuousVariable, AntLionOptimization, AntLionOptimizationConfig
+from pyvolutionary import Task, ContinuousMultiVariable, AntLionOptimization, AntLionOptimizationConfig
 
 ## Link: https://onlinelibrary.wiley.com/doi/pdf/10.1002/9781119136507.app2
 class ConstrainedBenchmark(Task):
@@ -453,12 +447,10 @@ class ConstrainedBenchmark(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
+lower_bounds = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+upper_bounds = [1, 1, 1, 1, 1, 1, 1, 1, 1, 100, 100, 100, 1]
 task = ConstrainedBenchmark(
-    variables=(
-        [ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=1) for i in range(9)] + [
-            ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=100) for i in range(9, 12)
-        ] + [ContinuousVariable(name=f"x12", lower_bound=0, upper_bound=1)]
-    )
+    variables=([ContinuousMultiVariable(name="x", lower_bounds=lower_bounds, upper_bounds=upper_bounds)])
 )
 
 configuration = AntLionOptimizationConfig(population_size=200, fitness_error=10e-4, max_cycles=400)
@@ -496,6 +488,135 @@ 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:
+
+```python
+from opfunu.cec_based.cec2017 import F52017
+
+from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, GridSearchCV
+
+f1 = F52017(30, f_bias=0)
+
+
+class Problem(Task):
+    # Link: https://en.wikipedia.org/wiki/Test_functions_for_optimization
+    def objective_function(self, solution):
+        return f1.evaluate(solution)
+
+
+# Define the task with the bounds and the configuration of the optimizer
+task = Problem(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
+)
+
+params_bbo_grid = {
+    "max_cycles": [10, 20, 30, 40],
+    "population_size": [50, 100, 150],
+    "n_elites": [3, 4, 5, 6],
+    "p_m": [0.01, 0.02, 0.05]
+}
+
+
+model = BiogeographyBasedOptimization()
+tuner = GridSearchCV(model, params_bbo_grid)
+
+tuner.execute(task=task)
+
+print(f"Best row {tuner.best_row}")
+print(f"Best score {tuner.best_score}")
+print(f"Best parameters {tuner.best_parameters}")
+
+best_result = tuner.resolve()
+print(f"Best solution after tuning {best_result.best_solution}")
+
+tuner.export_results("csv")
+tuner.export_results("dataframe")
+tuner.export_results("json")
+```
+
+### Multitasking
+**pyVolutionary** provides a `Multitask` class to perform multitasking optimization. The class can become very precious
+when you need to optimize multiple tasks with multiple algorithms in parallel. In case, for instance, of multiple tasks
+with the same algorithm, you can use the `Multitask` class to run the optimization in parallel. Furthermore, the
+`Multitask` class can be used to run multiple tasks with different algorithms in parallel. Here is an example of how
+to use the `Multitask` class:
+
+```python
+from opfunu.cec_based.cec2017 import F52017, F102017, F292017
+
+from pyvolutionary import (
+    ContinuousMultiVariable,
+    Task,
+    NuclearReactionOptimization,
+    Multitask,
+    NuclearReactionOptimizationConfig,
+    MountainGazelleOptimization,
+    MountainGazelleOptimizationConfig,
+    GrasshopperOptimization,
+    GrasshopperOptimizationConfig,
+    GizaPyramidConstructionOptimization,
+    GizaPyramidConstructionOptimizationConfig,
+)
+
+f1 = F52017(30, f_bias=0)
+f2 = F102017(30, f_bias=0)
+f3 = F292017(30, f_bias=0)
+
+
+class Problem1(Task):
+    def objective_function(self, solution):
+        return f1.evaluate(solution)
+
+
+class Problem2(Task):
+    def objective_function(self, solution):
+        return f3.evaluate(solution)
+
+
+class Problem3(Task):
+    def objective_function(self, solution):
+        return f1.evaluate(solution)
+
+
+task1 = Problem1(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
+)
+task2 = Problem2(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f2.lb, upper_bounds=f2.ub)],
+)
+task3 = Problem3(
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f3.lb, upper_bounds=f3.ub)],
+)
+
+model1 = NuclearReactionOptimization(
+    config=NuclearReactionOptimizationConfig(max_cycles=10000, population_size=50)
+)
+model2 = MountainGazelleOptimization(
+    config=MountainGazelleOptimizationConfig(max_cycles=10000, population_size=50)
+)
+model3 = GrasshopperOptimization(
+    config=GrasshopperOptimizationConfig(max_cycles=10000, population_size=50, c_min=0.00004, c_max=2.0,)
+)
+model4 = GizaPyramidConstructionOptimization(
+    config=GizaPyramidConstructionOptimizationConfig(
+        max_cycles=10000, population_size=50, theta=14, friction=[1, 10], prob_substitution=0.5,
+    )
+)
+
+multitask = Multitask(
+    algorithms=(model1, model2, model3, model4), tasks=(task1, task2, task3), modes=("thread", ), n_workers=4
+)
+
+multitask.execute(n_trials=2, n_jobs=2, debug=True)
+
+multitask.export_results("csv")
+multitask.export_results("dataframe")
+multitask.export_results("json")
+```
+
 ### Agent characteristics
 The characteristics of an agent can be extracted by using two functions:
 - `agent_trend`: it returns the trend of the agent at each iteration

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyVolutionary"
-version = "2.2.0"
+version = "2.4.0"
 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"
@@ -8,7 +8,7 @@ readme = "README.md"
 repository = "https://github.com/matteocacciola/pyvolutionary"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
-    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
     "Topic :: Scientific/Engineering",
     "Topic :: Software Development"
 ]
@@ -22,6 +22,8 @@ install = "^1.3.5"
 coverage = "^7.3.2"
 matplotlib = "^3.8.1"
 sphynx = "^0.0.3"
+pandas = "^2.2.0"
+opfunu = "^1.0.1"
 
 
 [tool.poetry.group.test.dependencies]

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyvolutionary/__init__.py

@@ -71,14 +71,18 @@ from .whales import *
 from .wildebeest_herd import *
 from .wind_driven import *
 from .zebra import *
+from .gridsearchcv import GridSearchCV
 from .enums import TaskType
+from .multitask import Multitask
 from .models import (
     OptimizationResult,
     Population,
     Agent,
     Task,
     ContinuousVariable,
+    ContinuousMultiVariable,
     DiscreteVariable,
+    DiscreteMultiVariable,
     PermutationVariable,
     MultiObjectiveVariable,
     BinaryVariable,

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyvolutionary/abstract.py

@@ -21,7 +21,7 @@ class OptimizationAbstract(ABC, Generic[T]):
     """
     EPS: Final[float] = np.finfo(float).eps
 
-    def __init__(self, config: BaseOptimizationConfig, debug: bool | None = False):
+    def __init__(self, config: BaseOptimizationConfig | None = None, debug: bool | None = False):
         """
         The constructor of the class.
         :param config: The configuration of the optimization algorithm.
@@ -41,12 +41,29 @@ class OptimizationAbstract(ABC, Generic[T]):
     def optimization_step(self):
         pass
 
+    @abstractmethod
+    def set_config_parameters(self, parameters: dict[str, Any]):
+        pass
+
     def before_initialization(self):
         pass
 
     def after_initialization(self):
         pass
 
+    @property
+    def configuration(self) -> BaseOptimizationConfig | None:
+        """
+        This property returns the configuration of the optimization algorithm.
+        :return: the configuration
+        :rtype: BaseOptimizationConfig
+        """
+        return self._config
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
     def _fcn(self, x: list[float] | np.ndarray) -> float | list[float]:
         """
         This method evaluates the objective function.
@@ -184,6 +201,9 @@ class OptimizationAbstract(ABC, Generic[T]):
         :return: the result of the optimization
         :rtype: OptimizationResult
         """
+        if not self._config:
+            raise ValueError("Invalid configuration")
+
         np.random.seed(task.seed)
         evolution: list[Population] = []
 
@@ -196,7 +216,7 @@ class OptimizationAbstract(ABC, Generic[T]):
             try:
                 self._mode = ModeSolver(mode)
             except ValueError:
-                raise ValueError("Invalid mode. Possible values are 'serial', 'thread' and 'process'")
+                raise ValueError("Invalid mode. Possible values are \"serial\", \"thread\" and \"process\"")
 
         self._task = task
         self.before_initialization()

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyvolutionary/african_vulture/african_vulture_optimization.py

@@ -1,3 +1,4 @@
+from typing import Any
 import numpy as np
 
 from ..helpers import (
@@ -23,9 +24,12 @@ class AfricanVultureOptimization(OptimizationAbstract):
         nature-inspired metaheuristic algorithm for global optimization problems. Computers & Industrial Engineering,
         158, 107408.
     """
-    def __init__(self, config: AfricanVultureOptimizationConfig, debug: bool | None = False):
+    def __init__(self, config: AfricanVultureOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
 
+    def set_config_parameters(self, parameters: dict[str, Any]):
+        self._config = AfricanVultureOptimizationConfig(**parameters)
+
     def optimization_step(self):
         def exploration_position_phase1(rand_pos: np.ndarray, position: np.ndarray) -> np.ndarray:
             best_x1 = np.array(best_list[0].position)

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyvolutionary/ant_colony/ant_colony_optimization.py

@@ -1,3 +1,4 @@
+from typing import Any
 import numpy as np
 
 from ..helpers import (
@@ -22,9 +23,12 @@ class AntColonyOptimization(OptimizationAbstract):
         européenne sur la vie artificielle, Paris, France, Elsevier Publishing, 134-142, 1991.
     [2] M. Dorigo, Optimization, Learning and Natural Algorithms, PhD thesis, Politecnico di Milano, Italy, 1992.
     """
-    def __init__(self, config: AntColonyOptimizationConfig, debug: bool | None = False):
+    def __init__(self, config: AntColonyOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
 
+    def set_config_parameters(self, parameters: dict[str, Any]):
+        self._config = AntColonyOptimizationConfig(**parameters)
+
     def optimization_step(self):
         def compute_sigma(ant: Ant) -> float:
             M = np.repeat(np.array(ant.position).reshape((1, -1)), pop_size, axis=0)

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyvolutionary/ant_lion/ant_lion_optimization.py

@@ -1,3 +1,4 @@
+from typing import Any
 import numpy as np
 
 from ..helpers import (
@@ -20,9 +21,12 @@ class AntLionOptimization(OptimizationAbstract):
     ----------
     [1] Mirjalili, S., 2015. The ant lion optimizer. Advances in engineering software, 83, pp.80-98.
     """
-    def __init__(self, config: AntLionOptimizationConfig, debug: bool | None = False):
+    def __init__(self, config: AntLionOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
 
+    def set_config_parameters(self, parameters: dict[str, Any]):
+        self._config = AntLionOptimizationConfig(**parameters)
+
     def optimization_step(self):
         def get_i_ratio() -> float:
             # I is the ratio in Equations (2.10) and (2.11)

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyvolutionary/aquila/aquila_optimization.py

@@ -1,3 +1,4 @@
+from typing import Any
 import numpy as np
 
 from ..helpers import (
@@ -22,9 +23,12 @@ class AquilaOptimization(OptimizationAbstract):
         Aquila optimizer: a novel meta-heuristic optimization algorithm. Computers & Industrial Engineering, 157,
         p.107250.
     """
-    def __init__(self, config: AquilaOptimizationConfig, debug: bool | None = False):
+    def __init__(self, config: AquilaOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
 
+    def set_config_parameters(self, parameters: dict[str, Any]):
+        self._config = AquilaOptimizationConfig(**parameters)
+
     def optimization_step(self):
         def move(idx: int, aquila: Aquila) -> Aquila:
             pos = np.array(aquila.position)

{pyvolutionary-2.2.0 → pyvolutionary-2.4.0}/pyvolutionary/archimede/archimede_optimization.py

@@ -20,9 +20,12 @@ class ArchimedeOptimization(OptimizationAbstract):
         algorithm: a new metaheuristic algorithm for solving optimization problems. Applied Intelligence, 51(3),
         pp.1531-1551.
     """
-    def __init__(self, config: ArchimedeOptimizationConfig, debug: bool | None = False):
+    def __init__(self, config: ArchimedeOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
 
+    def set_config_parameters(self, parameters: dict[str, Any]):
+        self._config = ArchimedeOptimizationConfig(**parameters)
+
     def _init_agent(
         self,
         position: list[Any] | np.ndarray | None = None,