Polars evaluator changes.

Polars evaluator now has an 'evalaute_flat' method that works with
dictionaries with symbols of flattened tensor variables. Tested.

Author: gialmisi

desdeo/problem/evaluator.py

@@ -1,12 +1,19 @@
 """Defines a Polars-based evaluator."""
 
 from enum import Enum
+from itertools import product
 
 import numpy as np
 import polars as pl
 
 from desdeo.problem.json_parser import MathParser, replace_str
-from desdeo.problem.schema import Constant, ObjectiveTypeEnum, Problem, TensorConstant, TensorVariable
+from desdeo.problem.schema import (
+    Constant,
+    ObjectiveTypeEnum,
+    Problem,
+    TensorConstant,
+    TensorVariable,
+)
 
 SUPPORTED_EVALUATOR_MODES = ["variables", "discrete"]
 SUPPORTED_VAR_DIMENSIONS = ["scalar", "vector"]
@@ -120,6 +127,7 @@ def __init__(self, problem: Problem, evaluator_mode: PolarsEvaluatorModesEnum =
 
         self.evaluator_mode = evaluator_mode
 
+        self.problem = problem
         # Gather any constants of the problem definition.
         self.problem_constants = problem.constants
         # Gather the objective functions
@@ -155,6 +163,7 @@ def __init__(self, problem: Problem, evaluator_mode: PolarsEvaluatorModesEnum =
         # Note, when calling an evaluate method, it is assumed the problem has been fully parsed.
         if self.evaluator_mode == PolarsEvaluatorModesEnum.variables:
             self.evaluate = self._polars_evaluate
+            self.evaluate_flat = self._polars_evaluate_flat
         elif self.evaluator_mode == PolarsEvaluatorModesEnum.discrete:
             self.evaluate = self._from_discrete_data
         else:
@@ -378,6 +387,58 @@ def _polars_evaluate(
         # return the dataframe and let the solver figure it out
         return agg_df
 
+    def _polars_evaluate_flat(
+        self,
+        xs: dict[str, list[float | int | bool]],
+    ) -> pl.DataFrame:
+        """Evaluate the problem with flattened variables.
+
+        Args:
+            xs (dict[str, list[float  |  int  |  bool]]): a dict with flattened variables.
+                E.g., if the original problem has a tensor variable 'X' with shape (2,2),
+                then the dictionary is expected to have entries names 'X_1_1', 'X_1_2',
+                'X_2_1', and 'X_2_2'. The dictionary is rebuilt and passed to
+                `self._evaluate`.
+
+        Note:
+            Each flattened variable is assumed to contain the same number of samples.
+                This means that if the entry 'X_1_1' of `xs` is, for example
+                `[1,2,3]`, this means that 'X_1_1' and all the other flattened
+                variables have three samples. This means also that the original
+                problem will be evaluated with a tensor variable with shape (2,2)
+                and three samples,
+                e.g., 'X=[[[1, 1], [1,1]], [[2, 2], [2, 2]], [[3, 3], [3, 3]]]'.
+
+        Returns:
+            pl.DataFrame: a dataframe with the original problem's evaluated functions.
+        """
+        # Assume all variables have the same number of samples
+        n_samples = len(next(iter(xs.values())))
+
+        fat_xs = {}
+
+        # iterate over the variables of the problem
+        for var in self.problem.variables:
+            if isinstance(var, TensorVariable):
+                # construct the indices
+                index_ranges = [range(upper) for upper in var.shape]
+                indices = product(*index_ranges)
+
+                # create list to be filled
+                tmp = np.ones((n_samples, *var.shape)) * np.nan
+
+                for index in indices:
+                    tmp[:, *(index)] = xs[f"{var.symbol}_{"_".join(str(x+1) for x in index)}"]
+
+                fat_xs[var.symbol] = tmp.tolist()
+
+            else:
+                # else, proceed normally
+                fat_xs[var.symbol] = xs[var.symbol]
+
+        # return result of regular evaluate
+        return self.evaluate(fat_xs)
+
     def _from_discrete_data(self) -> pl.DataFrame:
         """Evaluates the problem based on its discrete representation only.
 

tests/test_polars_evaluator.py

@@ -4,16 +4,18 @@
 import polars as pl
 import pytest
 
-# from desdeo.problem import PolarsEvaluator, river_pollution_problem, simple_test_problem, simple_knapsack_vectors
 from desdeo.problem import (
-    PolarsEvaluator,
     Objective,
+    ObjectiveTypeEnum,
+    PolarsEvaluator,
     Problem,
     TensorConstant,
     TensorVariable,
+    Variable,
+    VariableTypeEnum,
     river_pollution_problem,
-    simple_test_problem,
     simple_knapsack_vectors,
+    simple_test_problem,
 )
 from desdeo.problem.evaluator import find_closest_points
 
@@ -159,40 +161,86 @@ def test_knapsack_problem():
 
 
 @pytest.mark.polars
-def test_with_tensors():
-    """Test that GenericEvaluator raises an error when trying to initialize the evaluator with a problem with tensors."""
-    # define a modified version of the simple_knapsack_vectors test problem for the purpose
-    profit_values = [[3, 5], [6, 8]]
-    profits = TensorConstant(name="Profits", symbol="P", shape=[2, 2], values=profit_values)
-
-    choices = TensorVariable(
-        name="Chosen items",
+def test_evaluate_w_flattened():
+    """Test that the evaluator works when called with flattened vars."""
+    var = Variable(
+        name="x", symbol="x", lowerbound=0, upperbound=10, initial_value=5.2, variable_type=VariableTypeEnum.real
+    )
+
+    tensor_var_1 = TensorVariable(
+        name="X",
         symbol="X",
+        shape=[3],
+        variable_type=VariableTypeEnum.real,
+        lowerbounds=-1.1,
+        upperbounds=3.4,
+        initial_values=0.2,
+    )
+
+    tensor_var_2 = TensorVariable(
+        name="Y",
+        symbol="Y",
         shape=[2, 2],
-        variable_type="binary",
-        lowerbounds=[[0, 0], [0, 0]],
-        upperbounds=[[1, 1], [1, 1]],
-        initial_values=[[1, 1], [1, 1]],
+        variable_type=VariableTypeEnum.integer,
+        lowerbounds=-5,
+        upperbounds=3,
+        initial_values=2,
     )
 
-    profit_objective = Objective(
-        name="max profit",
+    variables = [var, tensor_var_1, tensor_var_2]
+
+    objective_1 = Objective(
+        name="f_1",
         symbol="f_1",
-        func="P@X",
-        maximize=True,
-        ideal=8,
-        nadir=0,
+        func="X[1] + X[2] + X[3] - x",
+        maximize=False,
+        objective_type=ObjectiveTypeEnum.analytical,
         is_linear=True,
-        is_convex=False,
-        is_twice_differentiable=False,
+        is_convex=True,
+        is_twice_differentiable=True,
     )
 
-    problem = Problem(
-        name="Simple two-objective Knapsack problem",
-        description="A simple variant of the classic combinatorial problem.",
-        constants=[profits],
-        variables=[choices],
-        objectives=[profit_objective],
+    objective_2 = Objective(
+        name="f_2",
+        symbol="f_2",
+        func="Y[1, 1] + Y[1, 2] + Y[2, 1] + Y[2, 2] - x",
+        maximize=False,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=True,
+        is_twice_differentiable=True,
     )
 
-    PolarsEvaluator(problem)  # fails
+    objectives = [objective_1, objective_2]
+
+    problem = Problem(name="Test Problem", description="Test problem", variables=variables, objectives=objectives)
+
+    evaluator = PolarsEvaluator(problem)
+
+    xs = {
+        "x": [2, 3],
+        "X": [[-0.9, 0.1, 1.2], [0.1, 1.1, 0.7]],
+        "Y": [[[-4.1, -3.9], [-3.1, -2.9]], [[-2.2, -1.9], [1.1, 2.2]]],
+    }
+
+    flat_xs = {
+        "x": [2, 3],
+        "X_1": [-0.9, 0.1],
+        "X_2": [0.1, 1.1],
+        "X_3": [1.2, 0.7],
+        "Y_1_1": [-4.1, -2.2],
+        "Y_1_2": [-3.9, -1.9],
+        "Y_2_1": [-3.1, 1.1],
+        "Y_2_2": [-2.9, 2.2],
+    }
+
+    res_flat = evaluator.evaluate_flat(flat_xs)
+    res_tensor = evaluator.evaluate(xs)
+
+    # should have the same results
+    npt.assert_allclose(res_flat["f_1"].to_numpy(), res_tensor["f_1"].to_numpy())
+    npt.assert_allclose(res_flat["f_2"].to_numpy(), res_tensor["f_2"].to_numpy())
+
+    # check correct objective function values
+    npt.assert_allclose(res_flat["f_1"].to_numpy(), [-1.6, -1.1])
+    npt.assert_allclose(res_flat["f_2"].to_numpy(), [-16, -3.8])