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

desdeo/emo/operators/evaluator.py

@@ -5,15 +5,14 @@ from collections.abc import Sequence
 
 import polars as pl
 
-from desdeo.problem import Evaluator, Problem
+from desdeo.problem import Problem, SimulatorEvaluator
 from desdeo.tools.message import (
     EvaluatorMessageTopics,
-    GenericMessage,
     IntMessage,
     Message,
     PolarsDataFrameMessage,
 )
-from desdeo.tools.patterns import Subscriber
+from desdeo.tools.patterns import Publisher, Subscriber
 
 
 class EMOEvaluator(Subscriber):
@@ -41,23 +40,20 @@ class EMOEvaluator(Subscriber):
         """The topics that the Evaluator is interested in."""
         return []
 
-    def __init__(
-        self,
-        problem: Problem,
-        verbosity: int = 1,
-        **kwargs,
-    ):
+    def __init__(self, problem: Problem, verbosity: int, publisher: Publisher):
         """Initialize the EMOEvaluator class."""
-        super().__init__(**kwargs)
+        super().__init__(
+            verbosity=verbosity,
+            publisher=publisher,
+        )
         self.problem = problem
         # TODO(@light-weaver, @gialmisi): This can be so much more efficient.
-        self.evaluator = lambda x: Evaluator(problem).evaluate(
+        self.evaluator = lambda x: SimulatorEvaluator(problem).evaluate(
             {name.symbol: x[name.symbol].to_list() for name in problem.get_flattened_variables()}, flat=True
         )
         self.variable_symbols = [name.symbol for name in problem.variables]
         self.population: pl.DataFrame
-        self.outs: pl.DataFrame
-        self.verbosity: int = verbosity
+        self.out: pl.DataFrame
         self.new_evals: int = 0
 
     def evaluate(self, population: pl.DataFrame) -> pl.DataFrame:
@@ -72,7 +68,7 @@ class EMOEvaluator(Subscriber):
         self.population = population
         out = self.evaluator(population)
         # remove variable_symbols from the output
-        self.out = out.drop(self.variable_symbols)
+        self.out = out.drop(self.variable_symbols, strict=False)
         self.new_evals = len(population)
         # merge the objectives and targets
 

desdeo/emo/operators/generator.py

@@ -10,7 +10,7 @@ from scipy.stats.qmc import LatinHypercube
 from desdeo.emo.operators.evaluator import EMOEvaluator
 from desdeo.problem import Problem, VariableTypeEnum
 from desdeo.tools.message import GeneratorMessageTopics, IntMessage, Message, PolarsDataFrameMessage
-from desdeo.tools.patterns import Subscriber
+from desdeo.tools.patterns import Publisher, Subscriber
 
 
 class BaseGenerator(Subscriber):
@@ -42,9 +42,9 @@ class BaseGenerator(Subscriber):
         """Return the message topics that the generator is interested in."""
         return []
 
-    def __init__(self, problem: Problem, **kwargs):
+    def __init__(self, problem: Problem, publisher: Publisher, verbosity: int):
         """Initialize the BaseGenerator class."""
-        super().__init__(**kwargs)
+        super().__init__(publisher=publisher, verbosity=verbosity)
         self.problem = problem
         self.variable_symbols = [var.symbol for var in problem.get_flattened_variables()]
         self.bounds = np.array([[var.lowerbound, var.upperbound] for var in problem.get_flattened_variables()])
@@ -103,7 +103,9 @@ class RandomGenerator(BaseGenerator):
     distribution of the points is uniform. If the seed is not provided, the seed is set to 0.
     """
 
-    def __init__(self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, **kwargs):
+    def __init__(
+        self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, verbosity: int, publisher: Publisher
+    ):
         """Initialize the RandomGenerator class.
 
         Args:
@@ -111,10 +113,11 @@ class RandomGenerator(BaseGenerator):
             evaluator (BaseEvaluator): The evaluator to evaluate the population.
             n_points (int): The number of points to generate for the initial population.
             seed (int): The seed for the random number generator.
-            kwargs: Additional keyword arguments. Check the Subscriber class for more information.
-                At the very least, the publisher argument should be provided.
+            verbosity (int): The verbosity level of the generator. A verbosity of 2 is needed if you want to maintain
+                an external archive. Otherwise, a verbosity of 1 is sufficient.
+            publisher (Publisher): The publisher to publish the messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.n_points = n_points
         self.evaluator = evaluator
         self.rng = np.random.default_rng(seed)
@@ -144,14 +147,16 @@ class RandomGenerator(BaseGenerator):
         """Update the generator based on the message."""
 
 
-class LHSGenerator(RandomGenerator):
+class LHSGenerator(BaseGenerator):
     """Class for generating Latin Hypercube Sampling (LHS) initial population for the MOEAs.
 
     This class generates the initial population by using the Latin Hypercube Sampling (LHS) method.
     If the seed is not provided, the seed is set to 0.
     """
 
-    def __init__(self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, **kwargs):
+    def __init__(
+        self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, verbosity: int, publisher: Publisher
+    ):
         """Initialize the LHSGenerator class.
 
         Args:
@@ -159,10 +164,13 @@ class LHSGenerator(RandomGenerator):
             evaluator (BaseEvaluator): The evaluator to evaluate the population.
             n_points (int): The number of points to generate for the initial population.
             seed (int): The seed for the random number generator.
-            kwargs: Additional keyword arguments. Check the Subscriber class for more information.
-                At the very least, the publisher argument should be provided.
+            verbosity (int): The verbosity level of the generator. A verbosity of 2 is needed if you want to maintain
+                an external archive. Otherwise, a verbosity of 1 is sufficient.
+            publisher (Publisher): The publisher to publish the messages.
         """
-        super().__init__(problem, evaluator, n_points, seed, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
+        self.n_points = n_points
+        self.evaluator = evaluator
         self.lhsrng = LatinHypercube(d=len(self.variable_symbols), seed=seed)
         self.seed = seed
 
@@ -196,7 +204,9 @@ class RandomBinaryGenerator(BaseGenerator):
     This class generates an initial population by randomly setting variable values to be either 0 or 1.
     """
 
-    def __init__(self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, **kwargs):
+    def __init__(
+        self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, verbosity: int, publisher: Publisher
+    ):
         """Initialize the RandomBinaryGenerator class.
 
         Args:
@@ -204,10 +214,11 @@ class RandomBinaryGenerator(BaseGenerator):
             evaluator (BaseEvaluator): The evaluator to evaluate the population.
             n_points (int): The number of points to generate for the initial population.
             seed (int): The seed for the random number generator.
-            kwargs: Additional keyword arguments. Check the Subscriber class for more information.
-                At the very least, the publisher argument should be provided.
+            verbosity (int): The verbosity level of the generator. A verbosity of 2 is needed if you want to maintain
+                an external archive. Otherwise, a verbosity of 1 is sufficient.
+            publisher (Publisher): The publisher to publish the messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.n_points = n_points
         self.evaluator = evaluator
         self.rng = np.random.default_rng(seed)
@@ -244,7 +255,9 @@ class RandomIntegerGenerator(BaseGenerator):
     the variables.
     """
 
-    def __init__(self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, **kwargs):
+    def __init__(
+        self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, verbosity: int, publisher: Publisher
+    ):
         """Initialize the RandomIntegerGenerator class.
 
         Args:
@@ -252,10 +265,11 @@ class RandomIntegerGenerator(BaseGenerator):
             evaluator (BaseEvaluator): The evaluator to evaluate the population.
             n_points (int): The number of points to generate for the initial population.
             seed (int): The seed for the random number generator.
-            kwargs: Additional keyword arguments. Check the Subscriber class for more information.
-                At the very least, the publisher argument should be provided.
+            verbosity (int): The verbosity level of the generator. A verbosity of 2 is needed if you want to maintain
+                an external archive. Otherwise, a verbosity of 1 is sufficient.
+            publisher (Publisher): The publisher to publish the messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.n_points = n_points
         self.evaluator = evaluator
         self.rng = np.random.default_rng(seed)
@@ -297,7 +311,9 @@ class RandomMixedIntegerGenerator(BaseGenerator):
     values to be integers or floats between the bounds of the variables.
     """
 
-    def __init__(self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, **kwargs):
+    def __init__(
+        self, problem: Problem, evaluator: EMOEvaluator, n_points: int, seed: int, verbosity: int, publisher: Publisher
+    ):
         """Initialize the RandomMixedIntegerGenerator class.
 
         Args:
@@ -305,10 +321,11 @@ class RandomMixedIntegerGenerator(BaseGenerator):
             evaluator (BaseEvaluator): The evaluator to evaluate the population.
             n_points (int): The number of points to generate for the initial population.
             seed (int): The seed for the random number generator.
-            kwargs: Additional keyword arguments. Check the Subscriber class for more information.
-                At the very least, the publisher argument should be provided.
+            verbosity (int): The verbosity level of the generator. A verbosity of 2 is needed if you want to maintain
+                an external archive. Otherwise, a verbosity of 1 is sufficient.
+            publisher (Publisher): The publisher to publish the messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.var_symbol_types = {
             VariableTypeEnum.real: [
                 var.symbol for var in problem.variables if var.variable_type == VariableTypeEnum.real
@@ -354,3 +371,89 @@ class RandomMixedIntegerGenerator(BaseGenerator):
 
     def update(self, message) -> None:
         """Update the generator based on the message."""
+
+
+class ArchiveGenerator(BaseGenerator):
+    """Class for getting initial population from an archive."""
+
+    def __init__(
+        self,
+        problem: Problem,
+        evaluator: EMOEvaluator,
+        publisher: Publisher,
+        verbosity: int,
+        solutions: pl.DataFrame,
+        **kwargs,  # just to dump seed
+    ):
+        """Initialize the ArchiveGenerator class.
+
+        Args:
+            problem (Problem): The problem to solve.
+            evaluator (BaseEvaluator): The evaluator to evaluate the population. Only used to check that the outputs
+                have the correct variables.
+            publisher (Publisher): The publisher to publish the messages.
+            verbosity (int): The verbosity level of the generator. A verbosity of 2 is needed if you want to maintain
+                an external archive. Otherwise, a verbosity of 1 is sufficient.
+            solutions (pl.DataFrame): The decision variable vectors to use as the initial population.
+        """
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
+        if not isinstance(solutions, pl.DataFrame):
+            raise ValueError("The solutions must be a polars DataFrame.")
+        if solutions.shape[0] == 0:
+            raise ValueError("The solutions DataFrame is empty.")
+        self.solutions = solutions
+        # self.outputs = outputs
+        if not set(self.solutions.columns) == set(self.variable_symbols):
+            raise ValueError("The solutions DataFrame must have the same columns as the problem variables.")
+        # TODO: Check that the outputs have the correct columns
+        self.evaluator = evaluator
+
+    def do(self) -> tuple[pl.DataFrame, pl.DataFrame]:
+        """Get the initial population from the archive.
+
+        Returns:
+            tuple[pl.DataFrame, pl.DataFrame]: The initial population as the first element,
+                the corresponding objectives, the constraint violations, and the targets as the second element.
+        """
+        self.outputs = self.evaluator.evaluate(self.solutions)
+        self.notify()
+        return self.solutions, self.outputs
+
+    def state(self) -> Sequence[Message]:
+        """Return the state of the generator.
+
+        This method overrides the state method of the BaseGenerator class, because the solutions and outputs are
+        already provided and not generated by the generator.
+
+        Returns:
+            dict: The state of the generator.
+        """
+        # TODO: Should we do it like this? Or just do super().state()?
+        # Maybe saying that zero evaluations have been done is misleading?
+        # idk
+        if self.verbosity == 0:
+            return []
+        if self.verbosity == 1:
+            return [
+                IntMessage(
+                    topic=GeneratorMessageTopics.NEW_EVALUATIONS,
+                    value=0,
+                    source=self.__class__.__name__,
+                ),
+            ]
+        # verbosity == 2
+        return [
+            PolarsDataFrameMessage(
+                topic=GeneratorMessageTopics.VERBOSE_OUTPUTS,
+                value=pl.concat([self.solutions, self.outputs], how="horizontal"),
+                source=self.__class__.__name__,
+            ),
+            IntMessage(
+                topic=GeneratorMessageTopics.NEW_EVALUATIONS,
+                value=0,
+                source=self.__class__.__name__,
+            ),
+        ]
+
+    def update(self, message) -> None:
+        """Update the generator based on the message."""