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

desdeo/problem/simulator_evaluator.py

@@ -5,29 +5,38 @@ import subprocess
 import sys
 from inspect import getfullargspec
 from pathlib import Path
+from urllib.parse import urlparse
 
 import joblib
 import numpy as np
 import polars as pl
-# import skops.io as sio
+import requests
 
 from desdeo.problem import (
+    MathParser,
     ObjectiveTypeEnum,
     PolarsEvaluator,
     PolarsEvaluatorModesEnum,
     Problem,
 )
+from desdeo.problem.external import ProviderParams, get_resolver, supported_schemes
+
+# external resolver to resolve providers for problems defined externally of DESDEO
+_external_resolver = get_resolver()
 
 
 class EvaluatorError(Exception):
     """Error raised when exceptions are encountered in an Evaluator."""
 
 
-class Evaluator:
+class SimulatorEvaluator:
     """A class for creating evaluators for simulator based and surrogate based objectives, constraints and extras."""
 
-    def __init__(
-        self, problem: Problem, params: dict[str, dict] | None = None, surrogate_paths: dict[str, Path] | None = None
+    def __init__(  # noqa: PLR0912
+        self,
+        problem: Problem,
+        params: dict[str, dict] | ProviderParams | None = None,
+        surrogate_paths: dict[str, Path] | None = None,
     ):
         """Creating an evaluator for simulator based and surrogate based objectives, constraints and extras.
 
@@ -62,6 +71,15 @@ class Evaluator:
             obj.symbol
             for obj in list(filter(lambda x: x.objective_type == ObjectiveTypeEnum.surrogate, problem.objectives))
         ]
+        if problem.scalarization_funcs is not None:
+            parser = MathParser()
+            self.scalarization_funcs = [
+                (func.symbol, parser.parse(func.func))
+                for func in problem.scalarization_funcs
+                if func.symbol is not None
+            ]
+        else:
+            self.scalarization_funcs = []
         # Gather any constraints' symbols
         if problem.constraints is not None:
             self.analytical_symbols = self.analytical_symbols + [
@@ -93,7 +111,10 @@ class Evaluator:
 
         # Gather the possible simulators
         self.simulators = problem.simulators if problem.simulators is not None else []
+
         # Gather the possibly given parameters
+        if params and not isinstance(params, dict):
+            params = params.model_dump()
         self.params = {}
         for sim in self.simulators:
             sim_params = params.get(sim.name, {}) if params is not None else {}
@@ -136,15 +157,37 @@ class Evaluator:
         for sim in self.simulators:
             # gather the possible parameters for the simulator
             params = self.params.get(sim.name, {})
-            # call the simulator with the decision variable values and parameters as dicts
-            res = subprocess.run(
-                [sys.executable, sim.file, "-d", str(xs), "-p", str(params)], capture_output=True, text=True
-            )
-            if res.returncode == 0:
-                # gather the simulation results (a dict) into the results dataframe
-                res_df = res_df.hstack(pl.DataFrame(json.loads(res.stdout)))
-            else:
-                raise EvaluatorError(res.stderr)
+            if sim.file is not None:
+                # call the simulator with the decision variable values and parameters as dicts
+                res = subprocess.run(
+                    [sys.executable, sim.file, "-d", str(xs), "-p", str(params)], capture_output=True, text=True
+                )
+                if res.returncode == 0:
+                    # gather the simulation results (a dict) into the results dataframe
+                    res_df = res_df.hstack(pl.DataFrame(json.loads(res.stdout)))
+                else:
+                    raise EvaluatorError(res.stderr)
+            elif sim.url is not None:
+                # call the endpoint
+                try:
+                    if isinstance(xs, pl.DataFrame):
+                        # if xs is a polars dataframe, convert it to a dict
+                        xs = xs.to_dict(as_series=False)
+                    scheme = urlparse(sim.url.url).scheme
+                    if scheme in supported_schemes:
+                        # desdeo
+                        res = _external_resolver.evaluate(sim.url.url, params, xs)
+                        res_df = res_df.hstack(pl.DataFrame(res))
+                        # parse res
+                    else:
+                        # http, https, etc...
+                        res = requests.get(sim.url.url, auth=sim.url.auth, json={"d": xs, "p": params})
+                        res.raise_for_status()  # raise an error if the request failed
+                        res_df = res_df.hstack(pl.DataFrame(res.json()))
+                except requests.RequestException as e:
+                    raise EvaluatorError(
+                        f"Failed to call the simulator at {sim.url}. Is the simulator server running?"
+                    ) from e
 
         # Evaluate the minimization form of the objective functions
         min_obj_columns = pl.DataFrame()
@@ -153,7 +196,11 @@ class Evaluator:
                 min_obj_columns = min_obj_columns.hstack(
                     res_df.select((min_max_mult * pl.col(f"{symbol}")).alias(f"{symbol}_min"))
                 )
-        return res_df.hstack(min_obj_columns)
+
+        res_df = res_df.hstack(min_obj_columns)
+        # If there are scalarization functions, evaluate them as well
+        scalarization_columns = res_df.select(*[expr.alias(symbol) for symbol, expr in self.scalarization_funcs])
+        return res_df.hstack(scalarization_columns)
 
     def _evaluate_surrogates(self, xs: dict[str, list[int | float]]) -> pl.DataFrame:
         """Evaluate the problem for the given decision variables using the surrogate models.
@@ -194,7 +241,10 @@ class Evaluator:
                 min_obj_columns = min_obj_columns.hstack(
                     res.select((min_max_mult * pl.col(f"{symbol}")).alias(f"{symbol}_min"))
                 )
-        return res.hstack(min_obj_columns)
+        res_df = res.hstack(min_obj_columns)
+        # If there are scalarization functions, evaluate them as well
+        scalarization_columns = res_df.select(*[expr.alias(symbol) for symbol, expr in self.scalarization_funcs])
+        return res_df.hstack(scalarization_columns)
 
     def _load_surrogates(self, surrogate_paths: dict[str, Path] | None = None):
         """Load the surrogate models from disk and store them within the evaluator.

desdeo/problem/testproblems/__init__.py

@@ -4,15 +4,21 @@ Pre-defined problems for, e.g.,
 testing and illustration purposed are defined here.
 """
 
-__all__ = [
+__all__ = [  # noqa: RUF022
     "binh_and_korn",
     "dtlz2",
     "forest_problem",
     "forest_problem_discrete",
-    "simple_knapsack",
-    "simple_knapsack_vectors",
+    "mcwb_equilateral_tbeam_problem",
+    "mcwb_hollow_rectangular_problem",
+    "mcwb_ragsdell1976_problem",
+    "mcwb_solid_rectangular_problem",
+    "mcwb_square_channel_problem",
+    "mcwb_tapered_channel_problem",
+    "mixed_variable_dimensions_problem",
     "momip_ti2",
     "momip_ti7",
+    "multi_valued_constraint_problem",
     "nimbus_test_problem",
     "pareto_navigator_test_problem",
     "re21",
@@ -22,8 +28,11 @@ __all__ = [
     "river_pollution_problem",
     "river_pollution_problem_discrete",
     "river_pollution_scenario",
+    "rocket_injector_design",
     "simple_data_problem",
     "simple_integer_test_problem",
+    "simple_knapsack",
+    "simple_knapsack_vectors",
     "simple_linear_test_problem",
     "simple_scenario_test_problem",
     "simple_test_problem",
@@ -33,22 +42,32 @@ __all__ = [
     "zdt1",
     "zdt2",
     "zdt3",
-    "rocket_injector_design",
-    "mixed_variable_dimensions_problem",
-    "mcwb_solid_rectangular_problem"
+    "best_cake_problem",
+    "dmitry_forest_problem_disc",
 ]
 
 
 from .binh_and_korn_problem import binh_and_korn
+from .cake_problem import best_cake_problem
+from .dmitry_forest_problem_discrete import dmitry_forest_problem_disc
 from .dtlz2_problem import dtlz2
 from .forest_problem import forest_problem, forest_problem_discrete
 from .knapsack_problem import simple_knapsack, simple_knapsack_vectors
+from .mcwb_problem import (
+    mcwb_equilateral_tbeam_problem,
+    mcwb_hollow_rectangular_problem,
+    mcwb_ragsdell1976_problem,
+    mcwb_solid_rectangular_problem,
+    mcwb_square_channel_problem,
+    mcwb_tapered_channel_problem,
+)
 from .mixed_variable_dimenrions_problem import mixed_variable_dimensions_problem
 from .momip_problem import momip_ti2, momip_ti7
+from .multi_valued_constraints import multi_valued_constraint_problem
 from .nimbus_problem import nimbus_test_problem
 from .pareto_navigator_problem import pareto_navigator_test_problem
 from .re_problem import re21, re22, re23, re24
-from .river_pollution_problem import (
+from .river_pollution_problems import (
     river_pollution_problem,
     river_pollution_problem_discrete,
     river_pollution_scenario,
@@ -67,7 +86,3 @@ from .spanish_sustainability_problem import (
     spanish_sustainability_problem_discrete,
 )
 from .zdt_problem import zdt1, zdt2, zdt3
-
-from .mcwb_problem import (mcwb_solid_rectangular_problem, mcwb_hollow_rectangular_problem,
-                           mcwb_equilateral_tbeam_problem, mcwb_square_channel_problem, mcwb_tapered_channel_problem,
-                           mcwb_ragsdell1976_problem)

desdeo/problem/testproblems/benchmarks_server.py

@@ -0,0 +1,120 @@
+# A FastAPI server to expose pymoo benchmark problems
+from typing import Any
+
+import polars as pl
+import requests
+from fastapi import FastAPI
+from pydantic import BaseModel
+from pymoo.problems import get_problem
+
+from desdeo.problem.schema import Objective, Problem, Simulator, Url, Variable
+
+
+class PymooParameters(BaseModel):
+    """Parameters for a pymoo problem instance."""
+
+    name: str
+    n_var: int
+    n_obj: int
+    minus: bool = False
+
+
+class ProblemInfo(BaseModel):
+    """Information about a pymoo problem instance."""
+
+    lower_bounds: dict[str, float]
+    """Lower bounds of the decision variables. Keys are the names of the decision variables, e.g. "x_1", "x_2", etc."""
+    upper_bounds: dict[str, float]
+    """Upper bounds of the decision variables."""
+    objective_names: list[str]
+
+
+app = FastAPI()
+
+
+def get_pymoo_problem(p: PymooParameters):
+    """Get a pymoo problem instance by name, number of variables, and number of objectives."""
+    params = p.model_dump()
+    params.pop("minus")
+    return get_problem(**params)
+
+
+@app.get("/evaluate")
+def evaluate(d: dict[str, list[float]], p: PymooParameters) -> dict[str, Any]:
+    """Evaluate a pymoo problem instance with given parameters and input values."""
+    problem = get_pymoo_problem(p)
+
+    xs_df = pl.DataFrame(d)
+
+    output = problem.evaluate(xs_df.to_numpy())
+    output_df = pl.DataFrame(output, schema=[f"f_{i + 1}" for i in range(problem.n_obj)])
+
+    return d | output_df.to_dict(as_series=False)
+
+
+@app.get("/info")
+def info(p: PymooParameters) -> ProblemInfo:
+    """Get information about a pymoo problem instance, including bounds and objective names."""
+    problem = get_pymoo_problem(p)
+    bounds = problem.bounds()
+
+    return ProblemInfo(
+        lower_bounds={f"x_{i + 1}": bounds[0][i] for i in range(problem.n_var)},
+        upper_bounds={f"x_{i + 1}": bounds[1][i] for i in range(problem.n_var)},
+        objective_names=[f"f_{i + 1}" for i in range(problem.n_obj)],
+    )
+
+
+url = "http://127.0.0.1"
+port = 8000
+
+
+def server_problem(parameters: PymooParameters) -> Problem:
+    """Create a Problem instance from pymoo parameters."""
+    try:
+        info = requests.get(url + f":{port}/info", json=parameters.model_dump())
+        info.raise_for_status()
+    except requests.RequestException as e:
+        raise RuntimeError("Failed to fetch problem info. Is the server running?") from e
+    info: ProblemInfo = ProblemInfo.model_validate(info.json())
+
+    simulator_url = Url(url=f"{url}:{port}/evaluate")
+
+    return Problem(
+        name=parameters.name,
+        description=f"Problem {parameters.name} with {parameters.n_var} variables and {parameters.n_obj} objectives.",
+        variables=[
+            Variable(
+                name=f"x_{i + 1}",
+                symbol=f"x_{i + 1}",
+                lowerbound=info.lower_bounds[f"x_{i + 1}"],
+                upperbound=info.upper_bounds[f"x_{i + 1}"],
+                variable_type="real",
+            )
+            for i in range(parameters.n_var)
+        ],
+        objectives=[
+            Objective(
+                name=f"f_{i + 1}",
+                symbol=f"f_{i + 1}",
+                simulator_path=simulator_url,
+                objective_type="simulator",
+                maximize=parameters.minus,
+            )
+            for i in range(parameters.n_obj)
+        ],
+        simulators=[
+            Simulator(
+                name="s1",
+                symbol="s1",
+                url=simulator_url,
+                parameter_options=parameters.model_dump(),
+            )
+        ],
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app)

desdeo/problem/testproblems/cake_problem.py

@@ -0,0 +1,185 @@
+"""Defines the 'best cake problem'."""
+
+from desdeo.problem.schema import (
+    Constant,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    Variable,
+    VariableTypeEnum,
+)
+
+PI = 3.14159265358979323846
+
+
+## Helper func
+def U(z: float):
+    return 4.0 * z * (1.0 - z)
+
+
+## Helper funcs to return string representations
+
+
+def bowl_str(z: str, a: str, invD: str) -> str:
+    tmp: str = f"({z} - {a})*{invD}"
+    return f"({tmp}*{tmp})"
+    # return f"{clamp01_str(f"{tmp}*{tmp}")}"
+
+
+def U_str(z: str) -> str:
+    tmp: str = f"(4*{z}*(1.0 - {z}))"
+    return f"({tmp}*{tmp})"
+
+
+def ripple_str(t: str) -> str:
+    tmp: str = f"Sin({PI} * {t})"
+    return f"({tmp}*{tmp})"
+
+
+# Objective function string representations
+def f0_str() -> str:
+    yliq: str = "(0.5*x5 + 0.3*x4 + 0.2*x3)"
+    v: str = (
+        f"(0.4 * {bowl_str('x1', 'T1', 'INV_D1')}) + "
+        f"(0.4 * {bowl_str(yliq, 'Y_LIQ_STAR', 'INV_D_YLIQ')}) + "
+        f" (0.2 * {ripple_str('((x1 + x6) - (T1 + T6))')})"
+    )
+    return f"14*({v})"
+
+
+def f1_str() -> str:
+    sbar: str = "((x2 + 0.5*x3)/1.5)"
+    w25: str = f"({U_str('x2')}*{U_str('x5')})"
+    d25: str = f"(({w25} - W25_STAR)*INV_DW25)"
+    v: str = f"(0.4*{bowl_str('x2', 'T2', 'INV_D2')}) + (0.3*{ripple_str(f'{sbar} - SBAR_STAR')}) +(0.3*{d25}*{d25})"
+    return f"14*({v})"
+
+
+def f2_str() -> str:
+    v: str = (
+        f"(0.35*{bowl_str('x6', 'T6', 'INV_D6')}) + "
+        f"(0.25*{bowl_str('x4', 'T4', 'INV_D4')}) + "
+        f"(0.4*{ripple_str('((x6 - 0.5*x4) - (T6 - 0.5*T4))')})"
+    )
+    return f"14*({v})"
+
+
+def f3_str() -> str:
+    w35: str = f"({U_str('x3')}*{U_str('x5')})"
+    d35: str = f"(({w35} - W35_STAR) * INV_DW35)"
+    v: str = f"(0.3*{bowl_str('x3', 'T3', 'INV_D3')}) + (0.3*{bowl_str('x5', 'T5', 'INV_D5')}) + (0.4*({d35}*{d35}))"
+    return f"14*({v})"
+
+
+def f4_str() -> str:
+    v: str = (
+        f"(0.25*{bowl_str('x2', 'T2', 'INV_D2')}) + "
+        f"(0.25*{bowl_str('x3', 'T3', 'INV_D3')}) + "
+        f"(0.20*{ripple_str('(x4 - T4)')}) + "
+        f"(0.30*{ripple_str('((x2 - x5) - (T2 - T5))')})"
+    )
+    return f"14*({v})"
+
+
+## The cake problem
+def best_cake_problem() -> Problem:
+    """Defines the best cake problem."""
+    variable_inits = [
+        ("Flour", 0.70),
+        ("Sugar", 0.10),
+        ("Butter", 0.40),
+        ("Eggs", 0.50),
+        ("Milk", 0.20),
+        ("Baking powder", 0.80),
+    ]
+    variables = [
+        Variable(
+            name=var[0],
+            symbol=f"x{i + 1}",
+            variable_type=VariableTypeEnum.real,
+            lowerbound=0.0,
+            upperbound=1.0,
+            initial_value=var[1],
+        )
+        for i, var in enumerate(variable_inits)
+    ]
+
+    constants_init = [
+        ("T1", 0.60),
+        ("T2", 0.35),
+        ("T3", 0.25),
+        ("T4", 0.30),
+        ("T5", 0.35),
+        ("T6", 0.40),
+        ("INV_D1", 1.0 / 0.60),
+        ("INV_D2", 1.0 / 0.65),
+        ("INV_D3", 1.0 / 0.75),
+        ("INV_D4", 1.0 / 0.70),
+        ("INV_D5", 1.0 / 0.65),
+        ("INV_D6", 1.0 / 0.60),
+        ("Y_LIQ_STAR", 0.5 * 0.35 + 0.3 * 0.30 + 0.2 * 0.25),
+        ("INV_D_YLIQ", 1.0 / 0.685),
+        ("SBAR_STAR", (0.35 + 0.5 * 0.25) / 1.5),
+        ("W25_STAR", U(0.35) * U(0.35)),
+        ("INV_DW25", 1.0 / 0.8281),
+        ("W35_STAR", U(0.25) * U(0.35)),
+        ("INV_DW35", 1.0 / 0.6825),
+    ]
+
+    constants = [Constant(name=const[0], symbol=const[0], value=const[1]) for const in constants_init]
+
+    objectives = [
+        Objective(
+            name="Dry/crumb error",
+            symbol="dry_crumb",
+            func=f0_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,  # right?
+        ),
+        Objective(
+            name="Sweetness/texture off-target",
+            symbol="sweet_texture",
+            func=f1_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="Rise/collapse risk",
+            symbol="rise_collapse",
+            func=f2_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="Moistness/grease imbalance",
+            symbol="moistness_grease",
+            func=f3_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="Browning/burn risk",
+            symbol="browning_burn",
+            func=f4_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+    ]
+
+    return Problem(
+        name="Cake problem",
+        description="Try to find the most delicious cake!",
+        constants=constants,
+        variables=variables,
+        objectives=objectives,
+    )

desdeo/problem/testproblems/dmitry_forest_problem_discrete.py

@@ -0,0 +1,71 @@
+"""A forest problem with discrete representation."""
+from pathlib import Path
+
+import polars as pl
+
+from desdeo.problem.schema import (
+    DiscreteRepresentation,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    Variable,
+    VariableTypeEnum,
+)
+
+
+def dmitry_forest_problem_disc() -> Problem:
+    """Implements the dmitry forest problem using Pareto front representation.
+
+    Returns:
+        Problem: A problem instance representing the forest problem.
+    """
+    path = Path(__file__)
+    while not str(path).endswith("/DESDEO"):
+        path = path.parent
+
+    path = path / "tests/data/dmitry_discrete_repr/dmitry_forest_problem_non_dom_solns.csv"
+
+    obj_names = ["Rev", "HA", "Carb", "DW"]
+
+    var_name = "index"
+
+    data = pl.read_csv(
+        path, has_header=True, columns=["Rev", "HA", "Carb", "DW"], separator=",", #decimal_comma=True
+    )
+
+    variables = [
+        Variable(
+            name=var_name,
+            symbol=var_name,
+            variable_type=VariableTypeEnum.integer,
+            lowerbound=0,
+            upperbound=len(data) - 1,
+            initial_value=0,
+        )
+    ]
+
+    objectives = [
+        Objective(
+            name=obj_name,
+            symbol=obj_name,
+            objective_type=ObjectiveTypeEnum.data_based,
+            ideal=data[obj_name].max(),
+            nadir=data[obj_name].min(),
+            maximize=True,
+        )
+        for obj_name in obj_names
+    ]
+
+    discrete_def = DiscreteRepresentation(
+        variable_values={"index": list(range(len(data)))},
+        objective_values=data[[obj.symbol for obj in objectives]].to_dict(),
+    )
+
+    return Problem(
+        name="Dmitry Forest Problem (Discrete)",
+        description="Defines a forest problem with four objectives: revenue, habitat availability, carbon storage, and deadwood.",
+        variables=variables,
+        objectives=objectives,
+        discrete_representation=discrete_def,
+        is_twice_differentiable=False,
+    )