desdeo 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

desdeo/tools/utils.py

@@ -1,8 +1,10 @@
 """General utilities related to solvers."""
 
 import shutil
+from collections.abc import Callable
 
 import numpy as np
+import polars as pl
 
 from desdeo.problem import (
     ObjectiveTypeEnum,
@@ -14,27 +16,60 @@ from desdeo.problem import (
     variable_dimension_enumerate,
 )
 from desdeo.tools.generics import BaseSolver
-from desdeo.tools.gurobipy_solver_interfaces import GurobipySolver
-from desdeo.tools.ng_solver_interfaces import NevergradGenericSolver
+from desdeo.tools.gurobipy_solver_interfaces import GurobipySolver, PersistentGurobipySolver
+from desdeo.tools.ng_solver_interfaces import NevergradGenericOptions, NevergradGenericSolver
 from desdeo.tools.proximal_solver import ProximalSolver
 from desdeo.tools.pyomo_solver_interfaces import (
+    BonminOptions,
+    CbcOptions,
+    IpoptOptions,
     PyomoBonminSolver,
     PyomoCBCSolver,
     PyomoGurobiSolver,
     PyomoIpoptSolver,
 )
-from desdeo.tools.scipy_solver_interfaces import ScipyDeSolver, ScipyMinimizeSolver
+from desdeo.tools.scipy_solver_interfaces import (
+    ScipyDeOptions,
+    ScipyDeSolver,
+    ScipyMinimizeOptions,
+    ScipyMinimizeSolver,
+)
 
 available_solvers = {
-    "scipy_minimize": ScipyMinimizeSolver,
-    "scipy_de": ScipyDeSolver,
-    "proximal": ProximalSolver,
-    "nevergrad": NevergradGenericSolver,
-    "pyomo_bonmin": PyomoBonminSolver,
-    "pyomo_cbc": PyomoCBCSolver,
-    "pyomo_ipopt": PyomoIpoptSolver,
-    "pyomo_gurobi": PyomoGurobiSolver,
-    "gurobipy": GurobipySolver,
+    "scipy_minimize": {
+        "constructor": ScipyMinimizeSolver,
+        "options": ScipyMinimizeOptions,
+    },
+    "scipy_de": {
+        "constructor": ScipyDeSolver,
+        "options": ScipyDeOptions,
+    },
+    "proximal": {
+        "constructor": ProximalSolver,
+        "options": None,
+    },
+    "nevergrad": {"constructor": NevergradGenericSolver, "options": NevergradGenericOptions},
+    "pyomo_bonmin": {
+        "constructor": PyomoBonminSolver,
+        "options": BonminOptions,
+    },
+    "pyomo_cbc": {
+        "constructor": PyomoCBCSolver,
+        "options": CbcOptions,
+    },
+    "pyomo_ipopt": {
+        "constructor": PyomoIpoptSolver,
+        "options": IpoptOptions,
+    },
+    "pyomo_gurobi": {"constructor": PyomoGurobiSolver, "options": None},
+    "gurobipy": {
+        "constructor": GurobipySolver,
+        "options": None,
+    },
+    "gurobipy_persistent": {
+        "constructor": PersistentGurobipySolver,
+        "options": None,
+    },
 }
 
 
@@ -66,7 +101,7 @@ def find_compatible_solvers(problem: Problem) -> list[BaseSolver]:
     if all_data_based and has_discrete and var_dim == VariableDimensionEnum.scalar:
         # problem has only data-based objectives and a discrete definition is available
         # return ProximalSolver as it is the only solver for data-based problems at the moment
-        return [available_solvers["proximal"]]
+        return [available_solvers["proximal"]["constructor"]]
 
     # check if the problem is differentiable and if it is mixed integer
     if (
@@ -78,7 +113,7 @@ def find_compatible_solvers(problem: Problem) -> list[BaseSolver]:
             VariableDomainTypeEnum.mixed,
         ]
     ):
-        solvers.append(available_solvers["pyomo_bonmin"])  # bonmin has to be installed
+        solvers.append(available_solvers["pyomo_bonmin"]["constructor"])  # bonmin has to be installed
 
     # check if the problem is differentiable and continuous
     if (
@@ -86,22 +121,22 @@ def find_compatible_solvers(problem: Problem) -> list[BaseSolver]:
         and shutil.which("ipopt")
         and problem.variable_domain in [VariableDomainTypeEnum.continuous]
     ):
-        solvers.append(available_solvers["pyomo_ipopt"])  # ipopt has to be installed
+        solvers.append(available_solvers["pyomo_ipopt"]["constructor"])  # ipopt has to be installed
 
     # check if the problem is linear
     if problem.is_linear:
-        solvers.append(available_solvers["gurobipy"])
+        solvers.append(available_solvers["gurobipy"]["constructor"])
     if problem.is_linear and shutil.which("gurobi"):
-        solvers.append(available_solvers["pyomo_gurobi"])  # gurobi has to be installed
+        solvers.append(available_solvers["pyomo_gurobi"]["constructor"])  # gurobi has to be installed
     if problem.is_linear and shutil.which("cbc"):
-        solvers.append(available_solvers["pyomo_cbc"])
+        solvers.append(available_solvers["pyomo_cbc"]["constructor"])
 
     # check if problem's variables are all scalars
     if var_dim == VariableDimensionEnum.scalar:
         # nevergrad and scipy solvers work with all(?) problems with only scalar valued variables
-        solvers.append(available_solvers["nevergrad"])
-        solvers.append(available_solvers["scipy_minimize"])
-        solvers.append(available_solvers["scipy_de"])
+        solvers.append(available_solvers["nevergrad"]["constructor"])
+        solvers.append(available_solvers["scipy_minimize"]["constructor"])
+        solvers.append(available_solvers["scipy_de"]["constructor"])
     return solvers
 
 
@@ -125,12 +160,17 @@ def guess_best_solver(problem: Problem) -> BaseSolver:  # noqa: PLR0911
     # check if problem has a discrete definition
     has_discrete = problem.discrete_representation is not None
 
-    if TensorVariable in problem.variables:
+    # TODO: when figured out what solver is best for problems with tensor variables: it seems that e.g. the
+    # forest problems don't work with pyomo_cbc. So VERY MUCH a quick fix to get something working, as those types of
+    # problems have been ok with gurobipy.
+
+    # if True in [isinstance(variable, TensorVariable) for variable in problem.variables]:
+    if False:
         if problem.is_linear and shutil.which("cbc"):
-            return available_solvers["pyomo_cbc"]
+            return available_solvers["pyomo_cbc"]["constructor"]
 
         if problem.is_linear:
-            return available_solvers["gurobipy"]
+            return available_solvers["gurobipy"]["constructor"]
 
         # check if the problem is differentiable and if it is mixed integer
         if (
@@ -142,7 +182,7 @@ def guess_best_solver(problem: Problem) -> BaseSolver:  # noqa: PLR0911
                 VariableDomainTypeEnum.mixed,
             ]
         ):
-            return available_solvers["pyomo_bonmin"]
+            return available_solvers["pyomo_bonmin"]["constructor"]
 
         # check if the problem is differentiable and continuous
         if (
@@ -150,23 +190,28 @@ def guess_best_solver(problem: Problem) -> BaseSolver:  # noqa: PLR0911
             and shutil.which("ipopt")
             and problem.variable_domain in [VariableDomainTypeEnum.continuous]
         ):
-            return available_solvers["pyomo_ipopt"]
+            return available_solvers["pyomo_ipopt"]["constructor"]
 
     if all_data_based and has_discrete:
         # problem has only data-based objectives and a discrete definition is available
         # guess proximal solver is best
-        return available_solvers["proximal"]
+        return available_solvers["proximal"]["constructor"]
 
     # check if the problem is linear
     if problem.is_linear:
-        return available_solvers["gurobipy"]
+        return available_solvers["gurobipy"]["constructor"]
 
     # check if the problem is differentiable and if it is mixed integer
-    if problem.is_twice_differentiable and shutil.which("bonmin") and problem.variable_domain in [
-        VariableDomainTypeEnum.integer,
-        VariableDomainTypeEnum.mixed,
-    ]:
-        return available_solvers["pyomo_bonmin"]
+    if (
+        problem.is_twice_differentiable
+        and shutil.which("bonmin")
+        and problem.variable_domain
+        in [
+            VariableDomainTypeEnum.integer,
+            VariableDomainTypeEnum.mixed,
+        ]
+    ):
+        return available_solvers["pyomo_bonmin"]["constructor"]
 
     # check if the problem is differentiable and continuous
     if (
@@ -174,10 +219,10 @@ def guess_best_solver(problem: Problem) -> BaseSolver:  # noqa: PLR0911
         and shutil.which("ipopt")
         and problem.variable_domain in [VariableDomainTypeEnum.continuous]
     ):
-        return available_solvers["pyomo_ipopt"]
+        return available_solvers["pyomo_ipopt"]["constructor"]
 
     # else, guess nevergrad heuristics to be the best
-    return available_solvers["nevergrad"]
+    return available_solvers["nevergrad"]["constructor"]
 
     # thigs to check: variable types, does the problem have constraint, constraint types, etc...
 
@@ -215,6 +260,7 @@ def get_corrected_ideal_and_nadir(problem: Problem) -> tuple[dict[str, float | N
 
     return ideal_point, nadir_point
 
+
 def get_corrected_ideal(problem: Problem) -> dict[str, float | None]:
     """Compute the corrected ideal point depending if an objective function is to be maximized or not.
 
@@ -235,12 +281,11 @@ def get_corrected_ideal(problem: Problem) -> dict[str, float | None]:
         msg = "Some of the objectives have not a defined ideal value."
         raise ValueError(msg)
 
-    ideal_point = {
-    objective.symbol: objective.ideal if not objective.maximize else -objective.ideal
-    for objective in problem.objectives
+    return {
+        objective.symbol: objective.ideal if not objective.maximize else -objective.ideal
+        for objective in problem.objectives
     }
 
-    return ideal_point
 
 def get_corrected_nadir(problem: Problem) -> dict[str, float | None]:
     """Compute the corrected nadir point depending if an objective function is to be maximized or not.
@@ -262,28 +307,27 @@ def get_corrected_nadir(problem: Problem) -> dict[str, float | None]:
         msg = "Some of the objectives have not a defined nadir value."
         raise ValueError(msg)
 
-    nadir_point = {
+    return {
         objective.symbol: objective.nadir if not objective.maximize else -objective.nadir
         for objective in problem.objectives
     }
 
-    return nadir_point
 
-def get_corrected_reference_point(problem: Problem, reference_point: dict[str, float]) -> dict[str, float]:
-    """Correct the components of a reference point.
+def flip_maximized_objective_values(problem: Problem, objective_values: dict[str, float]) -> dict[str, float]:
+    """Flips the objective values if the objective function is to be maximized.
 
-    Correct the components of a reference point by multiplying the components
-    related to maximized objective functions by -1.
+    Flips the objective values if the objective function is to be maximized by multiplying
+    the values related to maximized objective functions by -1.
 
     Args:
-        problem (Problem): the problem the reference point is related to.
-        reference_point (dict[str, float]): the reference point to be corrected.
+        problem (Problem): the problem the objective values are related to.
+        objective_values (dict[str, float]): the objective values to be flipped.
 
     Returns:
-        dict[str, float]: the corrected reference point.
+        dict[str, float]: the flipped objective values.
     """
     return {
-        obj.symbol: reference_point[obj.symbol] * -1 if obj.maximize else reference_point[obj.symbol]
+        obj.symbol: objective_values[obj.symbol] * -1 if obj.maximize else objective_values[obj.symbol]
         for obj in problem.objectives
     }
 
@@ -318,3 +362,27 @@ def payoff_table_method(problem: Problem, solver: BaseSolver = None) -> tuple[di
         else:
             nadir.append(np.max(po_table.T[i]))
     return numpy_array_to_objective_dict(problem, ideal), numpy_array_to_objective_dict(problem, nadir)
+
+
+def repair(lower_bounds: dict[str, float], upper_bounds: dict[str, float]) -> Callable[[pl.DataFrame], pl.DataFrame]:
+    """Repairs the offspring by clipping the values to be within the specified bounds.
+
+    Useful in evolutionary algorithms where offspring may go out of bounds due to crossover or mutation operations.
+
+    Args:
+        offspring (pl.DataFrame): The offspring to be repaired.
+        lower_bounds (dict[str, float]): The lower bounds for each variable.
+        upper_bounds (dict[str, float]): The upper bounds for each variable.
+
+    Returns:
+        Callable[[pl.DataFrame], pl.DataFrame]: A function that takes a DataFrame and returns a repaired DataFrame.
+    """
+
+    def actual_repair(offspring: pl.DataFrame) -> pl.DataFrame:
+        for var in offspring.columns:
+            offspring = offspring.with_columns(
+                pl.col(var).clip(lower_bound=lower_bounds[var], upper_bound=upper_bounds[var])
+            )
+        return offspring
+
+    return actual_repair

desdeo/tools/visualizations.py

@@ -0,0 +1,67 @@
+import plotly.graph_objects as go
+
+
+def scatter_plot_comparison(
+    *results, x_key="f_1", y_key="f_2", z_key=None, reference_point=None, names=None
+):
+    """
+    Plots multiple sets of data in a scatter plot (2D or 3D depending on the data).
+
+    Parameters:
+        *results: Variable number of result objects, each containing outputs with keys for x, y, and optionally z.
+        x_key: Key for the x-axis data in the outputs.
+        y_key: Key for the y-axis data in the outputs.
+        z_key: Key for the z-axis data in the outputs (optional, for 3D plots).
+        reference_point: A dictionary with keys matching x_key, y_key, and optionally z_key, representing the reference point to plot.
+        names: List of names for each data set to display in the legend.
+    """
+    traces = []
+    is_3d = z_key is not None and all(z_key in result.outputs for result in results)
+
+    if names is None:
+        names = [f"Dataset {i+1}" for i in range(len(results))]
+
+    for i, (result, name) in enumerate(zip(results, names)):
+        color = f"hsl({i * 360 / len(results)}, 100%, 50%)"  # Generate distinct colors
+        if is_3d:
+            trace = go.Scatter3d(
+                x=result.outputs[x_key],
+                y=result.outputs[y_key],
+                z=result.outputs[z_key],
+                mode="markers",
+                marker=dict(size=4, color=color, symbol="circle"),
+                name=name,
+            )
+        else:
+            trace = go.Scatter(
+                x=result.outputs[x_key],
+                y=result.outputs[y_key],
+                mode="markers",
+                marker=dict(size=8, color=color, symbol="circle"),
+                name=name,
+            )
+        traces.append(trace)
+
+    if reference_point:
+        if is_3d:
+            ref_trace = go.Scatter3d(
+                x=[reference_point[x_key]],
+                y=[reference_point[y_key]],
+                z=[reference_point[z_key]],
+                mode="markers",
+                marker=dict(size=4, color="black", symbol="circle"),
+                name="Reference Point",
+            )
+        else:
+            ref_trace = go.Scatter(
+                x=[reference_point[x_key]],
+                y=[reference_point[y_key]],
+                mode="markers",
+                marker=dict(size=8, color="black", symbol="circle"),
+                name="Reference Point",
+            )
+        traces.append(ref_trace)
+
+    fig = go.Figure(data=traces)
+
+    return fig

desdeo/utopia_stuff/utopia_problem.py

@@ -347,7 +347,7 @@ def utopia_problem(
             objectives=[f_1, f_2, f_3],
             constraints=constraints,
         ),
-        solver=available_solvers["gurobipy"],
+        solver=available_solvers["gurobipy"]["constructor"],
     )
 
     print(ideals)

desdeo/utopia_stuff/utopia_problem_old.py

@@ -359,7 +359,7 @@ def utopia_problem_old(problem_name: str = "Forest problem", holding: int = 1) -
             objectives=[f_1, f_2, f_3],
             constraints=constraints,
         ),
-        solver=available_solvers["gurobipy"],
+        solver=available_solvers["gurobipy"]["constructor"],
     )
 
     print(ideals)

{desdeo-2.0.0.dist-info → desdeo-2.1.1.dist-info}/METADATA

@@ -1,39 +1,48 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: desdeo
-Version: 2.0.0
+Version: 2.1.1
 Summary: DESDEO is a modular and open source framework for interactive multiobjective optimization.
-License: MIT
+License-Expression: MIT
+License-File: LICENSE
+Keywords: optimization,decision-support,multiobjective optimization,evolutionary optimization,interactive methods
 Author: Giovanni Misitano
 Author-email: giovanni.a.misitano@jyu.fi
-Requires-Python: >=3.12,<3.13
-Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12,<3.14
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: bayesian-optimization (>=1.0,<2.0)
-Requires-Dist: cvxpy[scip] (>=1.6.4,<2.0.0)
-Requires-Dist: greenlet (>=3.1.1,<4.0.0)
-Requires-Dist: gurobipy (>=12.0.0,<13.0.0)
-Requires-Dist: nevergrad (>=1.0.12,<2.0.0)
-Requires-Dist: numba (>=0.61.0,<0.62.0)
-Requires-Dist: numpy (>=2.2.0,<3.0.0)
-Requires-Dist: polars (>=1.17,<2.0)
-Requires-Dist: pyarrow (>=20.0.0,<21.0.0)
-Requires-Dist: pydantic (>=2.9,<3.0)
-Requires-Dist: pymoo (>=0.6.1.2,<0.7.0.0)
-Requires-Dist: pyomo (>=6.8,<7.0)
-Requires-Dist: pyparsing (>=3.0,<4.0)
-Requires-Dist: scipy (>=1.11.4,<2.0.0)
-Requires-Dist: shap (>=0.47.0,<0.48.0)
-Requires-Dist: sympy (>=1.0,<2.0)
-Requires-Dist: tsp-solver (>=0.1,<0.2)
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: bayesian-optimization (>=1.0)
+Requires-Dist: coco-experiment (>=2.8.2)
+Requires-Dist: cvxpy[scip] (>=1.6.4)
+Requires-Dist: greenlet (>=3.1.1)
+Requires-Dist: gurobipy (>=12.0.0)
+Requires-Dist: moocore (>=0.1.7)
+Requires-Dist: nevergrad (>=1.0.12)
+Requires-Dist: numba (>=0.61.0)
+Requires-Dist: numpy (>=2.2.0)
+Requires-Dist: plotly (>=6.0)
+Requires-Dist: polars (==1.30)
+Requires-Dist: pyarrow (>=20.0.0)
+Requires-Dist: pydantic (>=2.9)
+Requires-Dist: pydantic-settings (>=2.9)
+Requires-Dist: pymoo (>=0.6.1.2)
+Requires-Dist: pyomo (>=6.8)
+Requires-Dist: pyparsing (>=3.0)
+Requires-Dist: requests (>=2.32.0)
+Requires-Dist: scipy (>=1.11.4)
+Requires-Dist: shap (>=0.47.0)
+Requires-Dist: sympy (>=1.0)
+Requires-Dist: tsp-solver (>=0.1)
+Requires-Dist: websockets (>=15.0.1)
+Project-URL: Bug tracker, https://github.com/industrial-optimization-group/DESDEO/issues
+Project-URL: Documentation, https://desdeo.readthedocs.io/en/latest/
+Project-URL: Homepage, https://github.com/industrial-optimization-group/DESDEO
+Project-URL: Repository, https://github.com/industrial-optimization-group/DESDEO
 Description-Content-Type: text/markdown
 
+[![Discord](https://img.shields.io/discord/1382614276409266206?style=flat&label=Join%20our%20Discord&labelColor=%237289da)](https://discord.gg/uGCEgQTJyY) [![Documentation Status](https://img.shields.io/readthedocs/desdeo.svg?version=desdeo2&label=Documentation)](https://desdeo.readthedocs.io/en/latest/) ![Tests](https://img.shields.io/github/actions/workflow/status/industrial-optimization-group/DESDEO/unit_tests.yaml?branch=master&label=Tests)
+ 
 # DESDEO: the open-source software framework for interactive multiobjective optimization
-
-[![Documentation Status](https://img.shields.io/readthedocs/desdeo.svg?version=desdeo2&label=Documentation)](https://desdeo.readthedocs.io/en/latest/) ![Tests](https://img.shields.io/github/actions/workflow/status/industrial-optimization-group/DESDEO/unit_tests.yaml?branch=desdeo2&label=Tests)
-
-[![Discord server](https://dcbadge.vercel.app/api/server/TgSnUmzv5M)](https://discord.gg/TgSnUmzv5M)
-
 ## Introduction
 
 DESDEO is an open-source framework for interactive multiobjective optimization
@@ -108,19 +117,27 @@ currently the case with the web-API.
 
 ## Installation instructions
 
-For installing DESDEO, please see the documentation (TODO) for instructions.
+DESDEO is available on PyPI to be installed via pip:
+
+```bash
+pip install desdeo
+```
+
+However, some of DESDEO's features rely on 3rd party optimizers, which should be available on your system.
+To read more on these, and on instructions on how to install the latest version of DESDEO directly from Github,
+[check out the documentation](https://desdeo.readthedocs.io/en/latest/howtoguides/installing/).
 
 ## Documentation
 
 Care has been taken to make sure DESDEO is well documented, making it accessible
 to both newcomers and seasoned users alike.  [The documentation of DESDEO is
-available online.](https://desdeo.readthedocs.io/en/desdeo2/)
+available online.](https://desdeo.readthedocs.io/en/latest/)
 
 ## Contributing
 
 As DESDEO is an open source-project, anybody is welcome to contribute.
 An extensive tutorial to get started contributing to DESDEO
-[is available in the documentation](https://desdeo.readthedocs.io/en/desdeo2/tutorials/contributing/).
+[is available in the documentation](https://desdeo.readthedocs.io/en/latest/tutorials/contributing/).
 Be sure to check it out!
 
 For additional support for contributing to DESDEO,