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

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

desdeo/problem/testproblems/forest_problem.py

@@ -0,0 +1,275 @@
+from pathlib import Path
+
+import numpy as np
+import polars as pl
+
+from desdeo.problem.schema import (
+    Constraint,
+    ConstraintTypeEnum,
+    DiscreteRepresentation,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    TensorConstant,
+    TensorVariable,
+    Variable,
+    VariableTypeEnum,
+)
+
+def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1, comparing: bool = False) -> Problem:
+    r"""Defines a test forest problem that has TensorConstants and TensorVariables.
+
+    The problem has TensorConstants V, W and P as vectors taking values from a data file and
+    TensorVariables X_n, where n is the number of units in the data, as vectors matching the constants in shape.
+    The variables are binary and each variable vector X_i has one variable with the value 1 while others have value 0.
+    The variable with the value 1 for each vector X_i represents the optimal plan for the corresponding unit i.
+    The three objective functions f_1, f_2, f_3 represent the net present value, wood volume at the end of
+    the planning period, and the profit from harvesting.
+    All of the objective functions are to be maximized.
+    The problem is defined as follows:
+
+    \begin{align}
+        \max_{\mathbf{x}} & \quad \sum_{j=1}^N\sum_{i \in I_j} v_{ij} x_{ij} & \\
+        & \quad \sum_{j=1}^N\sum_{i \in I_j} w_{ij} x_{ij} & \\
+        & \quad \sum_{j=1}^N\sum_{i \in I_j} p_{ij} x_{ij} & \\
+        \text{s.t.} & \quad \sum\limits_{i \in I_j} x_{ij} = 1, & \forall j = 1 \ldots N \\
+        & \quad x_{ij}\in \{0,1\}& \forall j = 1 \ldots N, ~\forall i\in I_j,
+    \end{align}
+
+    where $x_{ij}$ are decision variables representing the choice of implementing management plan $i$ in stand $j$,
+    and $I_j$ is the set of available management plans for stand $j$. For each plan $i$ in stand $j$
+    the net present value, wood volume at the end of the planning period, and the profit from harvesting
+    are represented by $v_{ij}$, $w_{ij}$, and $p_{ij}$ respectively.
+
+    Args:
+        simulation_results (str): Location of the simulation results file.
+        treatment_key (str): Location of the file with the treatment information.
+        holding (int, optional): The number of the holding to be optimized. Defaults to 1.
+        comparing (bool, optional): Determines if solutions are to be compared to those from the rahti app.
+            Defaults to False.
+
+    Returns:
+        Problem: An instance of the test forest problem.
+    """
+    df = pl.read_csv(simulation_results, schema_overrides={"unit": pl.Float64})
+    df_key = pl.read_csv(treatment_key, schema_overrides={"unit": pl.Float64})
+
+    selected_df_v = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "npv_5_percent"])
+    unique_units = selected_df_v.unique(["unit"], maintain_order=True).get_column("unit")
+    selected_df_v.group_by(["unit", "schedule"])
+    rows_by_key = selected_df_v.rows_by_key(key=["unit", "schedule"])
+    v_array = np.zeros((selected_df_v["unit"].n_unique(), selected_df_v["schedule"].n_unique()))
+    for i in range(np.shape(v_array)[0]):
+        for j in range(np.shape(v_array)[1]):
+            if (unique_units[i], j) in rows_by_key:
+                v_array[i][j] = rows_by_key[(unique_units[i], j)][0]
+
+    # determine whether the results are to be compared to those from the rahti app (for testing purposes)
+    # if compared, the stock values are calculated by substacting the value after 2025 period from
+    # the value after the 2035 period (in other words, last value - first value)
+    if comparing:
+        selected_df_w = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "stock_2025", "stock_2035"])
+        selected_df_w.group_by(["unit", "schedule"])
+        rows_by_key = selected_df_w.rows_by_key(key=["unit", "schedule"])
+        selected_df_key_w = df_key.select(["unit", "schedule", "treatment"])
+        selected_df_key_w.group_by(["unit", "schedule"])
+        rows_by_key_df_key = selected_df_key_w.rows_by_key(key=["unit", "schedule"])
+        w_array = np.zeros((selected_df_w["unit"].n_unique(), selected_df_w["schedule"].n_unique()))
+        for i in range(np.shape(w_array)[0]):
+            for j in range(np.shape(w_array)[1]):
+                if len(rows_by_key_df_key[(unique_units[i], j)]) == 0:
+                    continue
+                if (unique_units[i], j) in rows_by_key:
+                    w_array[i][j] = rows_by_key[(unique_units[i], j)][0][1] - rows_by_key[(unique_units[i], j)][0][0]
+    else:
+        selected_df_w = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "stock_2035"])
+        selected_df_w.group_by(["unit", "schedule"])
+        rows_by_key = selected_df_w.rows_by_key(key=["unit", "schedule"])
+        selected_df_key_w = df_key.select(["unit", "schedule", "treatment"])
+        selected_df_key_w.group_by(["unit", "schedule"])
+        rows_by_key_df_key = selected_df_key_w.rows_by_key(key=["unit", "schedule"])
+        w_array = np.zeros((selected_df_w["unit"].n_unique(), selected_df_w["schedule"].n_unique()))
+        for i in range(np.shape(w_array)[0]):
+            for j in range(np.shape(w_array)[1]):
+                if len(rows_by_key_df_key[(unique_units[i], j)]) == 0:
+                    continue
+                if (unique_units[i], j) in rows_by_key:
+                    w_array[i][j] = rows_by_key[(unique_units[i], j)][0][0]
+
+    selected_df_p = df.filter(pl.col("holding") == holding).select(
+        ["unit", "schedule", "harvest_value_period_2025", "harvest_value_period_2030", "harvest_value_period_2035"]
+    )
+    selected_df_p.group_by(["unit", "schedule"])
+    rows_by_key = selected_df_p.rows_by_key(key=["unit", "schedule"])
+    p_array = np.zeros((selected_df_p["unit"].n_unique(), selected_df_p["schedule"].n_unique()))
+    for i in range(np.shape(p_array)[0]):
+        for j in range(np.shape(p_array)[1]):
+            if (unique_units[i], j) in rows_by_key:
+                p_array[i][j] = sum(rows_by_key[(unique_units[i], j)][0])
+
+    constants = []
+    variables = []
+    constraints = []
+    f_1_func = []
+    f_2_func = []
+    f_3_func = []
+    # define the constants V, W and P, decision variable X, constraints, and objective function expressions in one loop
+    for i in range(np.shape(v_array)[0]):
+        # Constants V, W and P
+        v = TensorConstant(
+            name=f"V_{i+1}",
+            symbol=f"V_{i+1}",
+            shape=[np.shape(v_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=v_array[i].tolist(),
+        )
+        constants.append(v)
+        w = TensorConstant(
+            name=f"W_{i+1}",
+            symbol=f"W_{i+1}",
+            shape=[np.shape(w_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=w_array[i].tolist(),
+        )
+        constants.append(w)
+        p = TensorConstant(
+            name=f"P_{i+1}",
+            symbol=f"P_{i+1}",
+            shape=[np.shape(p_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=p_array[i].tolist(),
+        )
+
+        # Decision variable X
+        constants.append(p)
+        x = TensorVariable(
+            name=f"X_{i+1}",
+            symbol=f"X_{i+1}",
+            variable_type=VariableTypeEnum.binary,
+            shape=[np.shape(v_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            lowerbounds=np.shape(v_array)[1] * [0],
+            upperbounds=np.shape(v_array)[1] * [1],
+            initial_values=np.shape(v_array)[1] * [0],
+        )
+        variables.append(x)
+
+        # Constraints
+        con = Constraint(
+            name=f"x_con_{i+1}",
+            symbol=f"x_con_{i+1}",
+            cons_type=ConstraintTypeEnum.EQ,
+            func=f"Sum(X_{i+1}) - 1",
+            is_linear=True,
+            is_convex=False,  # not checked
+            is_twice_differentiable=True,
+        )
+        constraints.append(con)
+
+        # Objective function expressions
+        exprs = f"V_{i+1}@X_{i+1}"
+        f_1_func.append(exprs)
+
+        exprs = f"W_{i+1}@X_{i+1}"
+        f_2_func.append(exprs)
+
+        exprs = f"P_{i+1}@X_{i+1}"
+        f_3_func.append(exprs)
+
+    # form the objective function sums
+    f_1_func = " + ".join(f_1_func)
+    f_2_func = " + ".join(f_2_func)
+    f_3_func = " + ".join(f_3_func)
+
+    f_1 = Objective(
+        name="Net present value",
+        symbol="f_1",
+        func=f_1_func,
+        maximize=True,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    f_2 = Objective(
+        name="Wood stock volume",
+        symbol="f_2",
+        func=f_2_func,
+        maximize=True,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    f_3 = Objective(
+        name="Harvest value",
+        symbol="f_3",
+        func=f_3_func,
+        maximize=True,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name="Forest problem",
+        description="A test forest problem.",
+        constants=constants,
+        variables=variables,
+        objectives=[f_1, f_2, f_3],
+        constraints=constraints,
+    )
+
+
+def forest_problem_discrete() -> Problem:
+    """Implements the forest problem using Pareto front representation.
+
+    Returns:
+        Problem: A problem instance representing the forest problem.
+    """
+    filename = "datasets/forest_holding_4.csv"
+
+    path = Path(__file__).parent.parent.parent.parent / filename
+
+    obj_names = ["stock", "harvest_value", "npv"]
+
+    var_name = "index"
+
+    data = pl.read_csv(
+        path, has_header=True, columns=["stock", "harvest_value", "npv"], 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="Finnish Forest Problem (Discrete)",
+        description="Defines a forest problem with three objectives: stock, harvest value, and net present value.",
+        variables=variables,
+        objectives=objectives,
+        discrete_representation=discrete_def,
+    )

desdeo/problem/testproblems/knapsack_problem.py

@@ -0,0 +1,163 @@
+from desdeo.problem.schema import (
+    Constant,
+    Constraint,
+    ConstraintTypeEnum,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    TensorConstant,
+    TensorVariable,
+    Variable,
+    VariableTypeEnum,
+)
+
+def simple_knapsack() -> Problem:
+    r"""Defines a simple multiobjective knapsack problem.
+
+    Given a set of 4 items, each with a weight and three values corresponding to
+    different objectives, the problem is defined as follows:
+
+    -   Item 1: weight = 2, values = (5, 10, 15)
+    -   Item 2: weight = 3, values = (4, 7, 9)
+    -   Item 3: weight = 1, values = (3, 5, 8)
+    -   Item 4: weight = 4, values = (2, 3, 5)
+
+    The problem is then to maximize the following functions:
+
+    \begin{align*}
+    f_1(x) &= 5x_1 + 4x_2 + 3x_3 + 2x_4 \\
+    f_2(x) &= 10x_1 + 7x_2 + 5x_3 + 3x_4 \\
+    f_3(x) &= 15x_1 + 9x_2 + 8x_3 + 5x_4 \\
+    \text{s.t.}\quad & 2x_1 + 3x_2 + 1x_3 + 4x_4 \leq 7 \\
+    & x_i \in \{0,1\} \quad \text{for} \quad i = 1, 2, 3, 4,
+    \end{align*}
+
+    where the inequality constraint is a weight constraint. The problem is a binary variable problem.
+
+    Returns:
+        Problem: the simple knapsack problem.
+    """
+    variables = [
+        Variable(
+            name=f"x_{i}",
+            symbol=f"x_{i}",
+            variable_type=VariableTypeEnum.binary,
+            lowerbound=0,
+            upperbound=1,
+            initial_value=0,
+        )
+        for i in range(1, 5)
+    ]
+
+    exprs = {
+        "f1": "5*x_1 + 4*x_2 + 3*x_3 + 2*x_4",
+        "f2": "10*x_1 + 7*x_2 + 5*x_3 + 3*x_4",
+        "f3": "15*x_1 + 9*x_2 + 8*x_3 + 5*x_4",
+    }
+
+    ideals = {"f1": 15, "f2": 25, "f3": 37}
+
+    objectives = [
+        Objective(
+            name=f"f_{i}",
+            symbol=f"f_{i}",
+            func=exprs[f"f{i}"],
+            maximize=True,
+            ideal=ideals[f"f{i}"],
+            nadir=0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_linear=True,
+            is_convex=True,
+            is_twice_differentiable=True,
+        )
+        for i in range(1, 4)
+    ]
+
+    constraints = [
+        Constraint(
+            name="Weight constraint",
+            symbol="g_w",
+            cons_type=ConstraintTypeEnum.LTE,
+            func="2*x_1 + 3*x_2 + 1*x_3 + 4*x_4 - 7",
+            is_linear=True,
+            is_convex=True,
+            is_twice_differentiable=True,
+        )
+    ]
+
+    return Problem(
+        name="Simple knapsack",
+        description="A simple knapsack problem with three objectives to be maximized.",
+        variables=variables,
+        objectives=objectives,
+        constraints=constraints,
+    )
+
+
+def simple_knapsack_vectors():
+    """Define a simple variant of the knapsack problem that utilizes vectors (TensorVariable and TensorConstant)."""
+    n_items = 4
+    weight_values = [2, 3, 4, 5]
+    profit_values = [3, 5, 6, 8]
+    efficiency_values = [4, 2, 7, 3]
+
+    max_weight = Constant(name="Maximum weights", symbol="w_max", value=5)
+
+    weights = TensorConstant(name="Weights of the items", symbol="W", shape=[len(weight_values)], values=weight_values)
+    profits = TensorConstant(name="Profits", symbol="P", shape=[len(profit_values)], values=profit_values)
+    efficiencies = TensorConstant(
+        name="Efficiencies", symbol="E", shape=[len(efficiency_values)], values=efficiency_values
+    )
+
+    choices = TensorVariable(
+        name="Chosen items",
+        symbol="X",
+        shape=[n_items],
+        variable_type="binary",
+        lowerbounds=n_items * [0],
+        upperbounds=n_items * [1],
+        initial_values=n_items * [1],
+    )
+
+    profit_objective = Objective(
+        name="max profit",
+        symbol="f_1",
+        func="P@X",
+        maximize=True,
+        ideal=8,
+        nadir=0,
+        is_linear=True,
+        is_convex=False,
+        is_twice_differentiable=False,
+    )
+
+    efficiency_objective = Objective(
+        name="max efficiency",
+        symbol="f_2",
+        func="E@X",
+        maximize=True,
+        ideal=7,
+        nadir=0,
+        is_linear=True,
+        is_convex=False,
+        is_twice_differentiable=False,
+    )
+
+    weight_constraint = Constraint(
+        name="Weight constraint",
+        symbol="g_1",
+        cons_type="<=",
+        func="W@X - w_max",
+        is_linear=True,
+        is_convex=False,
+        is_twice_differentiable=False,
+    )
+
+    return Problem(
+        name="Simple two-objective Knapsack problem",
+        description="A simple variant of the classic combinatorial problem.",
+        constants=[max_weight, weights, profits, efficiencies],
+        variables=[choices],
+        objectives=[profit_objective, efficiency_objective],
+        constraints=[weight_constraint],
+    )