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

desdeo/tools/indicators_binary.py

@@ -8,4 +8,110 @@ If these conditions are not met, the results of the indicators will not be meani
 Additionally, the set may be assumed to only contain mutually non-dominated solutions, depending on the indicator.
 
 For now, we rely on pymoo for the implementation of many of the indicators.
-"""
+"""
+
+from typing import Literal
+
+import numpy as np
+from moocore import epsilon_additive, epsilon_mult
+from numba import njit
+from desdeo.tools.non_dominated_sorting import dominates
+from desdeo.tools.indicators_unary import hv
+
+"""
+Note that the moocore package includes a more complex implementation for calculating the epsilon_indicator for two
+solution *sets*.
+"""
+
+
+@njit()
+def epsilon_component(solution1: np.ndarray, solution2: np.ndarray) -> float:
+    """Computes the additive epsilon-indicator between two solutions.
+
+    Basically, returns the minimum amount by which the values in solution1 must be translated (minimization assumed)
+    such that it (weakly) dominates solution2. If solution1 already dominates solution2, returns 0.0.
+
+    Args:
+        solution1 (np.ndarray): Should be an one-dimensional array, where each value is normalized between [0, 1]
+        solution2 (np.ndarray): Should be an one-dimensional array, where each value is normalized between [0, 1]
+
+    Returns:
+        float: The maximum distance between the values in s1 and s2.
+    """
+    return max(0.0, max(solution1 - solution2))
+
+
+@njit()
+def self_epsilon(solution_set: np.ndarray) -> np.ndarray:
+    """Computes the pairwise additive epsilon-indicator for a solution set.
+
+    Args:
+        solution_set (np.ndarray): Should be a two-dimensional array, where each row is a
+            solution normalized between [0, 1].
+
+    Returns:
+        np.ndarray: A two-dimensional array where the entry at (i, j) is the
+            additive epsilon-indicator between the i-th and j-th solution in the set.
+    """
+    n_solutions = solution_set.shape[0]
+    eps_matrix = np.zeros((n_solutions, n_solutions), dtype=np.float64)
+    for i in range(n_solutions):
+        for j in range(n_solutions):
+            eps_matrix[i, j] = epsilon_component(solution_set[i], solution_set[j])
+    return eps_matrix
+
+
+def epsilon_indicator(
+    set1: np.ndarray, set2: np.ndarray, kind: Literal["additive", "multiplicative"] = "additive"
+) -> float:
+    """Computes the additive epsilon-indicator between two solution sets.
+
+    Args:
+        set1 (np.ndarray): Should be a two-dimensional array, where each row is a solution normalized between [0, 1]
+        set2 (np.ndarray): Should be a two-dimensional array, where each row is a solution normalized between [0, 1]
+        kind (Literal["additive", "multiplicative"]): The kind of epsilon-indicator to compute. Defaults to "additive".
+
+    Returns:
+        float: the  epsilon-indicator between the two sets.
+    """
+    if kind == "additive":
+        return epsilon_additive(set1, ref=set2)
+    if kind == "multiplicative":
+        return epsilon_mult(set1, ref=set2)
+    raise ValueError(f"Unknown kind: {kind}. Use 'additive' or 'multiplicative'.")
+
+
+def hv_component(solution1: np.ndarray, solution2: np.ndarray, ref: float = 2.0) -> float:
+    """Computes the hypervolume contribution of solution1 with respect to solution2.
+
+    Args:
+        solution1 (np.ndarray): Should be an one-dimensional array, where each value is normalized between [0, 1]
+        solution2 (np.ndarray): Should be an one-dimensional array, where each value is normalized between [0, 1]
+        ref (float): The reference point for the hypervolume calculation. Defaults to 2.0.
+
+    Returns:
+        float: The hypervolume contribution of solution1 with respect to solution2.
+    """
+    if dominates(solution1, solution2):
+        return np.prod(ref - solution2) - np.prod(ref - solution1)
+    return hv(solution_set=np.array([solution1, solution2]), reference_point_component=ref)
+
+
+def self_hv(solution_set: np.ndarray, ref: float = 2.0) -> np.ndarray:
+    """Computes the pairwise hypervolume contribution for a solution set.
+
+    Args:
+        solution_set (np.ndarray): Should be a two-dimensional array, where each row is a
+            solution normalized between [0, 1].
+        ref (float): The reference point for the hypervolume calculation. Defaults to 2.0.
+
+    Returns:
+        np.ndarray: A two-dimensional array where the entry at (i, j) is the
+            hypervolume contribution of the i-th solution with respect to the j-th solution in the set.
+    """
+    n_solutions = solution_set.shape[0]
+    hv_matrix = np.zeros((n_solutions, n_solutions), dtype=np.float64)
+    for i in range(n_solutions):
+        for j in range(n_solutions):
+            hv_matrix[i, j] = hv_component(solution_set[i], solution_set[j], ref=ref)
+    return hv_matrix

desdeo/tools/indicators_unary.py

@@ -18,7 +18,7 @@ from warnings import warn
 
 import numpy as np
 from pydantic import BaseModel, Field
-from pymoo.indicators.hv import Hypervolume
+from moocore import Hypervolume
 from pymoo.indicators.rmetric import RMetric
 from scipy.spatial.distance import cdist
 from typing import Dict
@@ -37,15 +37,8 @@ def hv(solution_set: np.ndarray, reference_point_component: float) -> float:
     Returns:
         float: The hypervolume indicator value.
     """
-    rp = np.full(solution_set.shape[1], reference_point_component, dtype=np.float64)
-    ideal = np.zeros(solution_set.shape[1], dtype=np.float64)
-    nadir = np.ones(solution_set.shape[1], dtype=np.float64)
-
-    # Sets the ideal and nadir to (0, 0, ..., 0) and (1, 1, ..., 1) respectively.
-    # Turns of non-domination checks.
-    # Turns of normalization of the reference point
-    hv = Hypervolume(ref_point=rp, ideal=ideal, nadir=nadir, nds=False, norm_ref_point=False)
 
+    hv = Hypervolume(reference_point_component)
     ind = hv(solution_set)
 
     if ind is None:
@@ -80,13 +73,7 @@ def hv_batch(
     num_objs = solution_sets[next(iter(solution_sets.keys()))].shape[1]
 
     for rp in reference_points_component:
-        hv = Hypervolume(
-            ref_point=np.full(num_objs, rp, dtype=np.float64),
-            ideal=np.zeros(num_objs, dtype=np.float64),
-            nadir=np.ones(num_objs, dtype=np.float64),
-            nds=False,
-            norm_ref_point=False,
-        )
+        hv = Hypervolume(rp)
         for set_name in solution_sets:
             ind = hv(solution_sets[set_name])
             if ind is None:

desdeo/tools/message.py

@@ -3,6 +3,7 @@
 from enum import Enum
 from typing import Any, Literal
 
+import numpy as np
 from polars import DataFrame
 from pydantic import BaseModel, ConfigDict, Field, field_serializer
 
@@ -22,6 +23,8 @@ class CrossoverMessageTopics(Enum):
     """ The offsprings generated from the crossover. """
     ALPHA = "ALPHA"
     """ Alpha parameter used in crossover. """
+    LAMBDA = "LAMBDA"
+    """ Lambda parameter used in crossover. Primarily used in the bounded exponential xover. """
 
 
 class MutationMessageTopics(Enum):
@@ -100,6 +103,8 @@ class SelectorMessageTopics(Enum):
     """ The individuals selected by the selector. """
     SELECTED_OUTPUTS = "SELECTED_OUTPUTS"
     """ The targets of the selected individuals. """
+    SELECTED_FITNESS = "SELECTED_FITNESS"
+    """ The fitness of the selected individuals. This is the fitness calculated by the selector, not the objectives."""
     SELECTED_VERBOSE_OUTPUTS = "SELECTED_VERBOSE_OUTPUTS"
     """ Same as SELECTED_OUTPUTS + SELECTED_INDIVIDUALS"""
     REFERENCE_VECTORS = "REFERENCE_VECTORS"
@@ -125,6 +130,12 @@ class TerminatorMessageTopics(Enum):
     """ The maximum number of evaluations. """
 
 
+class ReferenceVectorMessageTopics(Enum):
+    """Topics for messages related to the reference vectors."""
+
+    TEST = "TEST"
+
+
 MessageTopics = (
     CrossoverMessageTopics
     | MutationMessageTopics
@@ -132,7 +143,10 @@ MessageTopics = (
     | GeneratorMessageTopics
     | SelectorMessageTopics
     | TerminatorMessageTopics
-    | Literal["ALL"]  # Used to indicate that all topics are of interest to a subscriber.
+    | ReferenceVectorMessageTopics
+    | Literal[
+        "ALL"
+    ]  # Used to indicate that all topics are of interest to a subscriber.
 )
 
 
@@ -176,7 +190,9 @@ class BoolMessage(BaseMessage):
 class DictMessage(BaseMessage):
     """A message containing a dictionary value."""
 
-    value: dict[str, Any] = Field(..., description="The dictionary value of the message.")
+    value: dict[str, Any] = Field(
+        ..., description="The dictionary value of the message."
+    )
     """ The dictionary value of the message. """
 
 
@@ -200,6 +216,19 @@ class PolarsDataFrameMessage(BaseMessage):
         return value.to_dict(as_series=False)
 
 
+class NumpyArrayMessage(BaseMessage):
+    """A message containing a numpy array value."""
+
+    value: np.ndarray = Field(..., description="The numpy array value of the message.")
+    """ The numpy array value of the message. """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @field_serializer("value")
+    def _serialize_value(self, value: np.ndarray) -> list[list[float]]:
+        return value.tolist()
+
+
 class GenericMessage(BaseMessage):
     """A message containing a generic value."""
 
@@ -216,6 +245,7 @@ Message = (
     | StringMessage
     | BoolMessage
     | PolarsDataFrameMessage
+    | NumpyArrayMessage
 )
 
 AllowedMessagesAtVerbosity: dict[int, tuple[type[Message], ...]] = {
@@ -230,5 +260,6 @@ AllowedMessagesAtVerbosity: dict[int, tuple[type[Message], ...]] = {
         Array2DMessage,
         GenericMessage,
         PolarsDataFrameMessage,
+        NumpyArrayMessage,
     ),
 }

desdeo/tools/non_dominated_sorting.py

@@ -76,10 +76,11 @@ def fast_non_dominated_sort(data: np.ndarray) -> np.ndarray:
         fronts[i] = current_front_all
 
         taken = taken + fronts[i]
-        if not fronts[i].any():
-            # if the current front is empty or if all the solutions have been sorted, stop
+        if taken.all():
+            # if all the solutions have been sorted, stop
             break
-    return fronts[:i]
+
+    return fronts[: i + 1]
 
 
 def fast_non_dominated_sort_indices(data: np.ndarray) -> list[np.ndarray]:

desdeo/tools/patterns.py

@@ -63,17 +63,18 @@ class Subscriber(ABC):
     def __init__(
         self,
         publisher: "Publisher",
-        verbosity: int = 1,
+        verbosity: int,
     ) -> None:
         """Initialize a subscriber.
 
         Args:
             publisher (Callable): the publisher to send messages to.
-            verbosity (int, optional): the verbosity level of the messages. Defaults to 1, which may mean differing
-                amounts of information depending on the message sender. A value of 0 means no messages at all.
+            verbosity (int, optional): the verbosity level of the messages. A value of 0 means no messages at all.
         """
         if not isinstance(verbosity, int):
             raise TypeError("Verbosity must be an integer.")
+        if verbosity < 0:
+            raise ValueError("Verbosity must be a non-negative integer.")
         self.publisher = publisher
         self.verbosity: int = verbosity
 
@@ -196,12 +197,13 @@ class Publisher:
             else:
                 self.registered_topics[topic].append(source)
 
-    def check_consistency(self) -> bool | tuple[bool, dict[MessageTopics, list[str]]]:
+    def check_consistency(self) -> tuple[bool, dict[MessageTopics, list[str]]]:
         """Check if all subscribed topics have also been registered by a source.
 
         Returns:
-            bool | tuple[bool, dict[MessageTopics, list[str]]]: True if all subscribed topics have been registered by a
-                source. False otherwise. If False, also return the unregistered topics that have been subscribed to.
+            tuple[bool, dict[MessageTopics, list[str]]]: Returns a tuple. The first element is a bool. True if all
+                subscribed topics have been registered by a source. False otherwise. The second element is a dictionary
+                of unregistered topics that have been subscribed to.
         """
         unregistered_topics = {}
         for topic in self.subscribers:
@@ -209,7 +211,7 @@ class Publisher:
                 unregistered_topics[topic] = [x.__class__.__name__ for x in self.subscribers[topic]]
         if unregistered_topics:
             return False, unregistered_topics
-        return True
+        return True, {}
 
     def relationship_map(self):
         """Make a diagram connecting sources to subscribers based on topics."""

desdeo/tools/pyomo_solver_interfaces.py

@@ -80,7 +80,7 @@ class IpoptOptions(BaseModel):
     max_iter: int = Field(description="Maximum number of iterations. Must be >1. Defaults to 3000.", default=3000)
     """Maximum number of iterations. Must be >1. Defaults to 3000."""
 
-    print_level: str = Field(
+    print_level: int = Field(
         description="The verbosity level of the solver's output. Ranges between 0 and 12. Defaults to 5.", default=5
     )
     """The verbosity level of the solver's output. Ranges between 0 and 12."""
@@ -100,61 +100,61 @@ class CbcOptions(BaseModel):
     model_config = ConfigDict(frozen=True, populate_by_name=True)
 
     sec: int = Field(
-        description="The maximum amount of time (in seconds) the solver should run. Defaults to None.", default=None
+        description="The maximum amount of time (in seconds) the solver should run. Defaults to 600.", default=600
     )
-    """The maximum amount of time (in seconds) the solver should run. Defaults to None."""
+    """The maximum amount of time (in seconds) the solver should run. Defaults to 600."""
 
     threads: int = Field(
-        description="Number of threads (cores) to use for solving the problem. Defaults to 1.", default=1
+        description="Number of threads (cores) to use for solving the problem. Defaults to 4.", default=4
     )
-    """Number of threads (cores) to use for solving the problem. Defaults to 1."""
+    """Number of threads (cores) to use for solving the problem. Defaults to 4."""
 
     log_level: int = Field(
         alias="logLevel",
         description=(
             "Controls the level of logging output. Values range from 0 (no output) to 5 (very detailed output)."
-            " Defaults to 1."
+            " Defaults to 2."
         ),
-        default=1,
+        default=2,
     )
     """Controls the level of logging output. Values range from 0 (no output) to 5 (very detailed output).
-    Defaults to 1.
+    Defaults to 2.
     """
 
     max_solutions: int = Field(
         alias="maxSolutions",
-        description="Limits the number of feasible solutions found by the solver. Defaults to None.",
-        default=None,
+        description="Limits the number of feasible solutions found by the solver. Defaults to 10.",
+        default=10,
     )
-    """Limits the number of feasible solutions found by the solver. Defaults to None."""
+    """Limits the number of feasible solutions found by the solver. Defaults to 10."""
 
     max_nodes: int = Field(
         alias="maxNodes",
-        description="Sets the maximum number of branch-and-bound nodes to explore. Defaults to None.",
-        default=None,
+        description="Sets the maximum number of branch-and-bound nodes to explore. Defaults to 1000.",
+        default=1000,
     )
-    """Sets the maximum number of branch-and-bound nodes to explore. Defaults to None."""
+    """Sets the maximum number of branch-and-bound nodes to explore. Defaults to 1000."""
 
     ratio_gap: float = Field(
         alias="ratioGap",
         description=(
             "Sets the relative MIP gap (as a fraction of the optimal solution value) at which the solver will"
-            " terminate. Defaults to None."
+            " terminate. Defaults to 0.01."
         ),
-        default=None,
+        default=0.01,
     )
     """Sets the relative MIP gap (as a fraction of the optimal solution value) at which the solver will terminate.
-    Defaults to None.
+    Defaults to 0.01.
     """
 
     absolute_gap: float = Field(
         alias="absoluteGap",
         description=(
-            "Sets the absolute MIP gap (an absolute value) at which the solver will terminate.  Defaults to None."
+            "Sets the absolute MIP gap (an absolute value) at which the solver will terminate.  Defaults to 1.0."
         ),
-        default=None,
+        default=1.0,
     )
-    """Sets the absolute MIP gap (an absolute value) at which the solver will terminate. Defaults to None."""
+    """Sets the absolute MIP gap (an absolute value) at which the solver will terminate. Defaults to 1.0."""
 
     solve: str = Field(
         description=(
@@ -168,9 +168,9 @@ class CbcOptions(BaseModel):
     """
 
     presolve: int = Field(
-        description="Controls the presolve level (0: no presolve, 1: default, 2: aggressive). Defaults to 1.", default=1
+        description="Controls the presolve level (0: no presolve, 1: default, 2: aggressive). Defaults to 2.", default=2
     )
-    """Controls the presolve level (0: no presolve, 1: default, 2: aggressive). Defaults to 1."""
+    """Controls the presolve level (0: no presolve, 1: default, 2: aggressive). Defaults to 2."""
 
     feasibility_tolerance: float = Field(
         alias="feasibilityTolerance",
@@ -187,19 +187,7 @@ class CbcOptions(BaseModel):
     """Sets the tolerance for integrality of integer variables. Defaults to 1e-5."""
 
 
-_default_cbc_options = CbcOptions(
-    sec=600,
-    threads=4,
-    logLevel=2,
-    maxSolutions=10,
-    maxNodes=1000,
-    ratioGap=0.01,
-    absoluteGap=1.0,
-    solve="branchAndCut",
-    presolve=2,
-    feasibilityTolerance=1e-6,
-    integerTolerance=1e-5,
-)
+_default_cbc_options = CbcOptions()
 """Defines CBC options with default values."""
 
 _default_bonmin_options = BonminOptions()
@@ -243,6 +231,31 @@ def parse_pyomo_optimizer_results(
     constraint_values = (
         {con.symbol: results[con.symbol] for con in problem.constraints} if problem.constraints else None
     )
+
+    # handle constraint, which might be multi-valued
+    if problem.constraints is not None:
+        constraint_values = {}
+
+        for con in problem.constraints:
+            result = results[con.symbol]
+
+            if isinstance(result, dict):
+                # multi-valued
+                indices = list(getattr(evaluator.model, con.symbol).keys())
+                shape = tuple(len({idx[k] for idx in indices}) for k in range(len(indices[0])))
+                values_list = np.zeros(shape)
+
+                for idx in indices:
+                    values_list[*[i - 1 for i in idx]] = result[idx]
+
+                constraint_values[con.symbol] = values_list.tolist()
+
+            else:
+                # scalar-valued
+                constraint_values[con.symbol] = result
+    else:
+        constraint_values = None
+
     extra_func_values = (
         {extra.symbol: results[extra.symbol] for extra in problem.extra_funcs}
         if problem.extra_funcs is not None