desdeo 1.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

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/binh_and_korn_problem.py

@@ -0,0 +1,88 @@
+from desdeo.problem.schema import (
+    Constant,
+    Constraint,
+    Objective,
+    Problem,
+    Variable,
+)
+
+def binh_and_korn(maximize: tuple[bool] = (False, False)) -> Problem:
+    """Create a pydantic dataclass representation of the Binh and Korn problem.
+
+    The function has two objective functions, two variables, and two constraint functions.
+    For testing purposes, it can be chosen whether the firs and second objective should
+    be maximized instead.
+
+    Arguments:
+        maximize (tuple[bool]): whether the first or second objective should be
+            maximized or not. Defaults to (False, False).
+
+    References:
+        Binh T. and Korn U. (1997) MOBES: A Multiobjective Evolution Strategy for Constrained Optimization Problems.
+            In: Proceedings of the Third International Conference on Genetic Algorithms. Czech Republic. pp. 176-182.
+    """
+    # These constants are for demonstrative purposes.
+    constant_1 = Constant(name="Four", symbol="c_1", value=4)
+    constant_2 = Constant(name="Five", symbol="c_2", value=5)
+
+    variable_1 = Variable(
+        name="The first variable", symbol="x_1", variable_type="real", lowerbound=0, upperbound=5, initial_value=2.5
+    )
+    variable_2 = Variable(
+        name="The second variable", symbol="x_2", variable_type="real", lowerbound=0, upperbound=3, initial_value=1.5
+    )
+
+    objective_1 = Objective(
+        name="Objective 1",
+        symbol="f_1",
+        func=f"{'-' if maximize[0] else ''}(c_1 * x_1**2 + c_1*x_2**2)",
+        # func=["Add", ["Multiply", "c_1", ["Square", "x_1"]], ["Multiply", "c_1", ["Square", "x_2"]]],
+        maximize=maximize[0],
+        ideal=0,
+        nadir=140 if not maximize[0] else -140,
+        is_linear=False,
+        is_convex=True,
+        is_twice_differentiable=True,
+    )
+    objective_2 = Objective(
+        name="Objective 2",
+        symbol="f_2",
+        # func=["Add", ["Square", ["Subtract", "x_1", "c_2"]], ["Square", ["Subtract", "x_2", "c_2"]]],
+        func=f"{'-' if maximize[1] else ''}((x_1 - c_2)**2 + (x_2 - c_2)**2)",
+        maximize=maximize[1],
+        ideal=0,
+        nadir=50 if not maximize[0] else -50,
+        is_linear=False,
+        is_convex=True,
+        is_twice_differentiable=True,
+    )
+
+    constraint_1 = Constraint(
+        name="Constraint 1",
+        symbol="g_1",
+        cons_type="<=",
+        func=["Add", ["Square", ["Subtract", "x_1", "c_2"]], ["Square", "x_2"], -25],
+        is_linear=False,
+        is_convex=True,
+        is_twice_differentiable=True,
+    )
+
+    constraint_2 = Constraint(
+        name="Constraint 2",
+        symbol="g_2",
+        cons_type="<=",
+        func=["Add", ["Negate", ["Square", ["Subtract", "x_1", 8]]], ["Negate", ["Square", ["Add", "x_2", 3]]], 7.7],
+        is_linear=False,
+        is_convex=True,
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name="The Binh and Korn function",
+        description="The two-objective problem used in the paper by Binh and Korn.",
+        constants=[constant_1, constant_2],
+        variables=[variable_1, variable_2],
+        objectives=[objective_1, objective_2],
+        constraints=[constraint_1, constraint_2],
+        is_twice_differentiable=True,
+    )

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,
+    )

desdeo/problem/testproblems/dtlz2_problem.py

@@ -0,0 +1,102 @@
+import numpy as np
+
+from desdeo.problem.schema import (
+    ExtraFunction,
+    Objective,
+    Problem,
+    Variable,
+    VariableTypeEnum,
+)
+
+def dtlz2(n_variables: int, n_objectives: int) -> Problem:
+    r"""Defines the DTLZ2 test problem.
+
+    The objective functions for DTLZ2 are defined as follows, for $i = 1$ to $M$:
+
+    \begin{equation}
+        \underset{\mathbf{x}}{\operatorname{min}}
+        f_i(\mathbf{x}) = (1+g(\mathbf{x}_M)) \prod_{j=1}^{M-i} \cos\left(x_j \frac{\pi}{2}\right) \times
+        \begin{cases}
+        1 & \text{if } i=1 \\
+        \sin\left(x_{(M-i+1)}\frac{\pi}{2}\right) & \text{otherwise},
+        \end{cases}
+    \end{equation}
+
+    where
+
+    \begin{equation}
+    g(\mathbf{x}_M) = \sum_{x_i \in \mathbf{x}_M} \left( x_i - 0.5 \right)^2,
+    \end{equation}
+
+    and $\mathbf{x}_M$ represents the last $n-k$ dimensions of the decision vector.
+    Pareto optimal solutions to the DTLZ2 problem consist of $x_i = 0.5$ for
+    all $x_i \in\mathbf{x}_{M}$, and $\sum{i=1}^{M} f_i^2 = 1$.
+
+    Args:
+        n_variables (int): number of variables.
+        n_objectives (int): number of objective functions.
+
+    Returns:
+        Problem: an instance of the DTLZ2 problem with `n_variables` variables and `n_objectives` objective
+            functions.
+
+    References:
+        Deb, K., Thiele, L., Laumanns, M., Zitzler, E. (2005). Scalable Test
+            Problems for Evolutionary Multiobjective Optimization. In: Abraham, A.,
+            Jain, L., Goldberg, R. (eds) Evolutionary Multiobjective Optimization.
+            Advanced Information and Knowledge Processing. Springer.
+    """
+    # function g
+    g_symbol = "g"
+    g_expr = " + ".join([f"(x_{i} - 0.5)**2" for i in range(n_objectives, n_variables + 1)])
+    g_expr = "1 + " + g_expr
+
+    objectives = []
+    for m in range(1, n_objectives + 1):
+        # function f_m
+        prod_expr = " * ".join([f"Cos(0.5 * {np.pi} * x_{i})" for i in range(1, n_objectives - m + 1)])
+        if m > 1:
+            prod_expr += f"{' * ' if prod_expr != "" else ""}Sin(0.5 * {np.pi} * x_{n_objectives - m + 1})"
+        if prod_expr == "":
+            prod_expr = "1"  # When m == n_objectives, the product is empty, implying f_M = g.
+        f_m_expr = f"({g_symbol}) * ({prod_expr})"
+
+        objectives.append(
+            Objective(
+                name=f"f_{m}",
+                symbol=f"f_{m}",
+                func=f_m_expr,
+                maximize=False,
+                ideal=0,
+                nadir=1,  # Assuming the range of g and the trigonometric functions
+                is_convex=False,
+                is_linear=False,
+                is_twice_differentiable=True,
+            )
+        )
+
+    variables = [
+        Variable(
+            name=f"x_{i}",
+            symbol=f"x_{i}",
+            variable_type=VariableTypeEnum.real,
+            lowerbound=0,
+            upperbound=1,
+            initial_value=1.0,
+        )
+        for i in range(1, n_variables + 1)
+    ]
+
+    extras = [
+        ExtraFunction(
+            name="g", symbol=g_symbol, func=g_expr, is_convex=False, is_linear=False, is_twice_differentiable=True
+        ),
+    ]
+
+    return Problem(
+        name="dtlz2",
+        description="The DTLZ2 test problem.",
+        variables=variables,
+        objectives=objectives,
+        extra_funcs=extras,
+    )