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

desdeo/emo/__init__.py

@@ -1,29 +1,159 @@
 """Imports available from the desdeo emo."""
 
 __all__ = [
-    "rvea",
-    "nsga3",
-    "template1",
-    "NSGAIII_select",
-    "RVEASelector",
-    "SimulatedBinaryCrossover",
-    "BoundedPolynomialMutation",
-    "LHSGenerator",
-    "RandomGenerator",
-    "EMOEvaluator",
-    "MaxEvaluationsTerminator",
-    "MaxGenerationsTerminator",
-    "Archive",
-    "FeasibleArchive",
-    "NonDominatedArchive",
+    "algorithms",
+    "crossover",
+    "generator",
+    "mutation",
+    "other",
+    "preference_handling",
+    "repair",
+    "scalar_selection",
+    "selection",
+    "templates",
+    "termination",
 ]
 
-from .hooks.archivers import Archive, FeasibleArchive, NonDominatedArchive
-from .methods.bases import template1
-from .methods.EAs import nsga3, rvea
-from .operators.crossover import SimulatedBinaryCrossover
-from .operators.evaluator import EMOEvaluator
-from .operators.generator import LHSGenerator, RandomGenerator
-from .operators.mutation import BoundedPolynomialMutation
-from .operators.selection import NSGAIII_select, RVEASelector
-from .operators.termination import MaxEvaluationsTerminator, MaxGenerationsTerminator
+from types import SimpleNamespace
+
+from .options.algorithms import (
+    emo_constructor,
+    ibea_mixed_integer_options,
+    ibea_options,
+    nsga2_options,
+    nsga3_mixed_integer_options,
+    nsga3_options,
+    rvea_mixed_integer_options,
+    rvea_options,
+)
+from .options.crossover import (
+    BlendAlphaCrossoverOptions,
+    BoundedExponentialCrossoverOptions,
+    LocalCrossoverOptions,
+    SimulatedBinaryCrossoverOptions,
+    SingleArithmeticCrossoverOptions,
+    SinglePointBinaryCrossoverOptions,
+    UniformIntegerCrossoverOptions,
+    UniformMixedIntegerCrossoverOptions,
+)
+from .options.generator import (
+    LHSGeneratorOptions,
+    RandomBinaryGeneratorOptions,
+    RandomGeneratorOptions,
+    RandomIntegerGeneratorOptions,
+    RandomMixedIntegerGeneratorOptions,
+)
+from .options.mutation import (
+    BinaryFlipMutationOptions,
+    BoundedPolynomialMutationOptions,
+    IntegerRandomMutationOptions,
+    MixedIntegerRandomMutationOptions,
+    MPTMutationOptions,
+    NonUniformMutationOptions,
+    PowerMutationOptions,
+    SelfAdaptiveGaussianMutationOptions,
+)
+from .options.repair import ClipRepairOptions, NoRepairOptions
+from .options.scalar_selection import RouletteWheelSelectionOptions, TournamentSelectionOptions
+from .options.selection import (
+    IBEASelectorOptions,
+    NSGA2SelectorOptions,
+    NSGA3SelectorOptions,
+    ReferenceVectorOptions,
+    RVEASelectorOptions,
+)
+from .options.templates import (
+    DesirableRangesOptions,
+    NonPreferredSolutionsOptions,
+    PreferredSolutionsOptions,
+    ReferencePointOptions,
+    Template1Options,
+    Template2Options,
+)
+from .options.termination import (
+    CompositeTerminatorOptions,
+    ExternalCheckTerminatorOptions,
+    MaxEvaluationsTerminatorOptions,
+    MaxGenerationsTerminatorOptions,
+    MaxTimeTerminatorOptions,
+)
+
+# Just didn't want to have a thousand imports in the main namespace
+algorithms = SimpleNamespace(
+    rvea_options=rvea_options,
+    nsga2_options=nsga2_options,
+    nsga3_options=nsga3_options,
+    ibea_options=ibea_options,
+    rvea_mixed_integer_options=rvea_mixed_integer_options,
+    nsga3_mixed_integer_options=nsga3_mixed_integer_options,
+    ibea_mixed_integer_options=ibea_mixed_integer_options,
+    emo_constructor=emo_constructor,
+)
+
+termination = SimpleNamespace(
+    MaxEvaluationsTerminatorOptions=MaxEvaluationsTerminatorOptions,
+    MaxGenerationsTerminatorOptions=MaxGenerationsTerminatorOptions,
+    MaxTimeTerminatorOptions=MaxTimeTerminatorOptions,
+    CompositeTerminatorOptions=CompositeTerminatorOptions,
+    ExternalCheckTerminatorOptions=ExternalCheckTerminatorOptions,
+)
+
+selection = SimpleNamespace(
+    IBEASelectorOptions=IBEASelectorOptions,
+    NSGA3SelectorOptions=NSGA3SelectorOptions,
+    NSGA2SelectorOptions=NSGA2SelectorOptions,
+    RVEASelectorOptions=RVEASelectorOptions,
+)
+
+other = SimpleNamespace(
+    ReferenceVectorOptions=ReferenceVectorOptions,
+)
+
+scalar_selection = SimpleNamespace(
+    TournamentSelectionOptions=TournamentSelectionOptions,
+    RouletteWheelSelectionOptions=RouletteWheelSelectionOptions,
+)
+
+mutation = SimpleNamespace(
+    BinaryFlipMutationOptions=BinaryFlipMutationOptions,
+    BoundedPolynomialMutationOptions=BoundedPolynomialMutationOptions,
+    IntegerRandomMutationOptions=IntegerRandomMutationOptions,
+    MixedIntegerRandomMutationOptions=MixedIntegerRandomMutationOptions,
+    MPTMutationOptions=MPTMutationOptions,
+    NonUniformMutationOptions=NonUniformMutationOptions,
+    PowerMutationOptions=PowerMutationOptions,
+    SelfAdaptiveGaussianMutationOptions=SelfAdaptiveGaussianMutationOptions,
+)
+
+generator = SimpleNamespace(
+    LHSGeneratorOptions=LHSGeneratorOptions,
+    RandomBinaryGeneratorOptions=RandomBinaryGeneratorOptions,
+    RandomGeneratorOptions=RandomGeneratorOptions,
+    RandomIntegerGeneratorOptions=RandomIntegerGeneratorOptions,
+    RandomMixedIntegerGeneratorOptions=RandomMixedIntegerGeneratorOptions,
+)
+
+templates = SimpleNamespace(
+    Template1Options=Template1Options,
+    Template2Options=Template2Options,
+)
+
+repair = SimpleNamespace(NoRepairOptions=NoRepairOptions, ClipRepairOptions=ClipRepairOptions)
+
+preference_handling = SimpleNamespace(
+    ReferencePointOptions=ReferencePointOptions,
+    DesirableRangesOptions=DesirableRangesOptions,
+    PreferredSolutionsOptions=PreferredSolutionsOptions,
+    NonPreferredSolutionsOptions=NonPreferredSolutionsOptions,
+)
+
+crossover = SimpleNamespace(
+    BlendAlphaCrossoverOptions=BlendAlphaCrossoverOptions,
+    BoundedExponentialCrossoverOptions=BoundedExponentialCrossoverOptions,
+    LocalCrossoverOptions=LocalCrossoverOptions,
+    SimulatedBinaryCrossoverOptions=SimulatedBinaryCrossoverOptions,
+    SingleArithmeticCrossoverOptions=SingleArithmeticCrossoverOptions,
+    SinglePointBinaryCrossoverOptions=SinglePointBinaryCrossoverOptions,
+    UniformIntegerCrossoverOptions=UniformIntegerCrossoverOptions,
+    UniformMixedIntegerCrossoverOptions=UniformMixedIntegerCrossoverOptions,
+)

desdeo/emo/hooks/archivers.py

@@ -5,6 +5,7 @@ from collections.abc import Sequence
 import polars as pl
 
 from desdeo.problem import Problem
+from desdeo.tools.generics import EMOResult
 from desdeo.tools.message import (
     EvaluatorMessageTopics,
     GeneratorMessageTopics,
@@ -72,6 +73,14 @@ class BaseArchive(Subscriber):
                 self.selections = pl.concat([self.selections, data], how="vertical")
             return
 
+    @property
+    def results(self) -> EMOResult:
+        """Return the results of the archiver."""
+        dec_vars = [x.symbol for x in self.problem.get_flattened_variables()]
+        all_cols = self.solutions.columns
+        non_decs = [col for col in all_cols if col not in dec_vars]
+        return EMOResult(optimal_variables=self.solutions[dec_vars], optimal_outputs=self.solutions[non_decs])
+
 
 class FeasibleArchive(BaseArchive):
     """An archiver that stores all feasible solutions evaluated during evolution."""
@@ -104,7 +113,7 @@ class FeasibleArchive(BaseArchive):
         data = message.value
         feasible_mask = (data[self.cons_symb] <= 0).to_numpy().all(axis=1)
         feasible_data = data.filter(feasible_mask)
-        feasible_data = data.with_columns(generation=self.generation_number)
+        feasible_data = feasible_data.with_columns(generation=self.generation_number)
         if self.solutions is None:
             self.solutions = feasible_data
         else:
@@ -135,7 +144,7 @@ class Archive(BaseArchive):
 
 
 class NonDominatedArchive(Archive):
-    """An archiver that stores only the non-dominated solutions evaluated during evolution."""
+    """An archiver that stores only the feasible non-dominated solutions evaluated during evolution."""
 
     def __init__(self, *, problem: Problem, publisher: Publisher):
         """Initialize the archiver.
@@ -146,6 +155,10 @@ class NonDominatedArchive(Archive):
         """
         super().__init__(problem=problem, publisher=publisher)
         self.targets = [f"{x.symbol}_min" for x in problem.objectives]
+        if problem.constraints is None:
+            self.cons_symb = []
+        else:
+            self.cons_symb = [x.symbol for x in problem.constraints]
 
     def update(self, message: Message) -> None:
         """Update the archiver with the new data.
@@ -163,6 +176,9 @@ class NonDominatedArchive(Archive):
         data = data.with_columns(generation=self.generation_number)
         if type(data) is not pl.DataFrame:
             raise ValueError("Data should be a polars DataFrame")
+        if self.cons_symb:
+            feasible_mask = (data[self.cons_symb] <= 0).to_numpy().all(axis=1)
+            data = data.filter(feasible_mask)
         if self.solutions is None:
             non_dom_mask = non_dominated(data[self.targets].to_numpy())
             self.solutions = data.filter(non_dom_mask)

desdeo/emo/methods/EAs.py

@@ -1,18 +1,33 @@
-"""Implements common evolutionary algorithms for multi-objective optimization."""
+"""[Deprecated] Implements common evolutionary algorithms for multi-objective optimization.
+
+Use desdeo.emo.options.algorithms instead.
+"""
 
 from collections.abc import Callable
 from functools import partial
+from warnings import warn
+
+import numpy as np
 
-from desdeo.emo.methods.bases import EMOResult, template1
+from desdeo.emo.methods.templates import EMOResult, template1, template2
 from desdeo.emo.operators.crossover import SimulatedBinaryCrossover, UniformMixedIntegerCrossover
 from desdeo.emo.operators.evaluator import EMOEvaluator
 from desdeo.emo.operators.generator import LHSGenerator, RandomMixedIntegerGenerator
 from desdeo.emo.operators.mutation import BoundedPolynomialMutation, MixedIntegerRandomMutation
-from desdeo.emo.operators.selection import NSGAIII_select, ReferenceVectorOptions, RVEASelector
+from desdeo.emo.operators.scalar_selection import TournamentSelection
+from desdeo.emo.operators.selection import IBEASelector, NSGA3Selector, ReferenceVectorOptions, RVEASelector
 from desdeo.emo.operators.termination import MaxEvaluationsTerminator, MaxGenerationsTerminator
 from desdeo.problem import Problem
+from desdeo.tools.indicators_binary import self_epsilon
 from desdeo.tools.patterns import Publisher
 
+warn(
+    "desdeo.emo.methods.EAs is deprecated and will be removed in future versions. "
+    "Please use desdeo.emo.options.algorithms instead.",
+    category=DeprecationWarning,
+    stacklevel=1,
+)
+
 
 def rvea(
     *,
@@ -159,7 +174,7 @@ def nsga3(
         verbosity=forced_verbosity if forced_verbosity is not None else 2,
     )
 
-    selector = NSGAIII_select(
+    selector = NSGA3Selector(
         problem=problem,
         publisher=publisher,
         verbosity=forced_verbosity if forced_verbosity is not None else 2,
@@ -216,6 +231,114 @@ def nsga3(
     )
 
 
+def ibea(
+    *,
+    problem: Problem,
+    population_size: int = 100,
+    n_generations: int = 100,
+    max_evaluations: int | None = None,
+    kappa: float = 0.05,
+    binary_indicator: Callable[[np.ndarray], np.ndarray] = self_epsilon,
+    seed: int = 0,
+    forced_verbosity: int | None = None,
+) -> tuple[Callable[[], EMOResult], Publisher]:
+    """Implements the Indicator-Based Evolutionary Algorithm (IBEA).
+
+    References:
+        Zitzler, E., Künzli, S. (2004). Indicator-Based Selection in Multiobjective Search. In: Yao, X., et al.
+        Parallel Problem Solving from Nature - PPSN VIII. PPSN 2004. Lecture Notes in Computer Science, vol 3242.
+        Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-540-30217-9_84
+
+    Args:
+        problem (Problem): The problem to be solved.
+        population_size (int, optional): The size of the population. Defaults to 100.
+        n_generations (int, optional): The number of generations to run the algorithm. Defaults to 100.
+        max_evaluations (int | None, optional): The maximum number of evaluations to run the algorithm. If None, the
+            algorithm will run for n_generations. Defaults to None. If both n_generations and max_evaluations are
+            provided, the algorithm will run until max_evaluations is reached.
+        kappa (float, optional): The kappa value for the IBEA selection. Defaults to 0.05.
+        binary_indicator (Callable[[np.ndarray], np.ndarray], optional): A binary indicator function that takes the
+            target values and returns a binary indicator for each individual. Defaults to self_epsilon with uses
+            binary adaptive epsilon indicator.
+        seed (int, optional): The seed for the random number generator. Defaults to 0.
+        forced_verbosity (int | None, optional): If not None, the verbosity of the algorithm is forced to this value.
+            Defaults to None.
+
+    Returns:
+        tuple[Callable[[], EMOResult], Publisher]: A tuple containing the function to run the algorithm and the
+            publisher object. The publisher object can be used to subscribe to the topics of the algorithm components,
+            as well as to inject additional functionality such as archiving the results.
+    """
+    publisher = Publisher()
+    evaluator = EMOEvaluator(
+        problem=problem,
+        publisher=publisher,
+        verbosity=forced_verbosity if forced_verbosity is not None else 2,
+    )
+    selector = IBEASelector(
+        problem=problem,
+        verbosity=forced_verbosity if forced_verbosity is not None else 2,
+        publisher=publisher,
+        population_size=population_size,
+        kappa=kappa,
+        binary_indicator=binary_indicator,
+    )
+    generator = LHSGenerator(
+        problem=problem,
+        evaluator=evaluator,
+        publisher=publisher,
+        n_points=population_size,
+        seed=seed,
+        verbosity=forced_verbosity if forced_verbosity is not None else 1,
+    )
+    crossover = SimulatedBinaryCrossover(
+        problem=problem,
+        publisher=publisher,
+        seed=seed,
+        verbosity=forced_verbosity if forced_verbosity is not None else 1,
+    )
+    mutation = BoundedPolynomialMutation(
+        problem=problem,
+        publisher=publisher,
+        seed=seed,
+        verbosity=forced_verbosity if forced_verbosity is not None else 1,
+    )
+    if max_evaluations is not None:
+        terminator = MaxEvaluationsTerminator(max_evaluations, publisher=publisher)
+    else:
+        terminator = MaxGenerationsTerminator(
+            n_generations,
+            publisher=publisher,
+        )
+
+    scalar_selector = TournamentSelection(publisher=publisher, verbosity=0, winner_size=population_size, seed=seed)
+
+    components = [
+        evaluator,
+        generator,
+        crossover,
+        mutation,
+        selector,
+        terminator,
+        scalar_selector,
+    ]
+    [publisher.auto_subscribe(x) for x in components]
+    [publisher.register_topics(x.provided_topics[x.verbosity], x.__class__.__name__) for x in components]
+    return (
+        partial(
+            template2,
+            evaluator=evaluator,
+            crossover=crossover,
+            mutation=mutation,
+            generator=generator,
+            selection=selector,
+            terminator=terminator,
+            mate_selection=scalar_selector,
+        ),
+        publisher,
+    )
+
+
 def nsga3_mixed_integer(
     *,
     problem: Problem,
@@ -261,7 +384,7 @@ def nsga3_mixed_integer(
         verbosity=forced_verbosity if forced_verbosity is not None else 2,
     )
 
-    selector = NSGAIII_select(
+    selector = NSGA3Selector(
         problem=problem,
         publisher=publisher,
         verbosity=forced_verbosity if forced_verbosity is not None else 2,

desdeo/emo/methods/bases.py

@@ -1,59 +1,12 @@
-"""This module contains the basic functional implementations for the EMO methods.
+"""Deprecated module."""
 
-This can be used as a template for the implementation of the EMO methods.
-"""
+import warnings
 
-import numpy as np
-import polars as pl
-from pydantic import BaseModel, ConfigDict, Field
+from desdeo.emo.methods.templates import EMOResult, template1, template2
 
-from desdeo.emo.operators.crossover import BaseCrossover
-from desdeo.emo.operators.evaluator import EMOEvaluator
-from desdeo.emo.operators.generator import BaseGenerator
-from desdeo.emo.operators.mutation import BaseMutation
-from desdeo.emo.operators.selection import BaseSelector
-from desdeo.emo.operators.termination import BaseTerminator
-
-
-class EMOResult(BaseModel):
-    solutions: pl.DataFrame = Field(description="The decision vectors of the final population.")
-    """The decision vectors of the final population."""
-    outputs: pl.DataFrame = Field(
-        description="The objective vectors, constraint vectors, and targets of the final population."
-    )
-    """The objective vectors, constraint vectors, and targets of the final population."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-def template1(
-    evaluator: EMOEvaluator,
-    crossover: BaseCrossover,
-    mutation: BaseMutation,
-    generator: BaseGenerator,
-    selection: BaseSelector,
-    terminator: BaseTerminator,
-) -> EMOResult:
-    """Implements a template that many EMO methods, such as RVEA and NSGA-III, follow.
-
-    Args:
-        evaluator (EMOEvaluator): A class that evaluates the solutions and provides the objective vectors, constraint
-            vectors, and targets.
-        crossover (BaseCrossover): The crossover operator.
-        mutation (BaseMutation): The mutation operator.
-        generator (BaseGenerator): A class that generates the initial population.
-        selection (BaseSelector): The selection operator.
-        terminator (BaseTerminator): The termination operator.
-
-    Returns:
-        EMOResult: The final population and their objective vectors, constraint vectors, and targets
-    """
-    solutions, outputs = generator.do()
-
-    while not terminator.check():
-        offspring = crossover.do(population=solutions)
-        offspring = mutation.do(offspring, solutions)
-        offspring_outputs = evaluator.evaluate(offspring)
-        solutions, outputs = selection.do(parents=(solutions, outputs), offsprings=(offspring, offspring_outputs))
-
-    return EMOResult(solutions=solutions, outputs=outputs)
+warnings.warn(
+    "The EMO methods in this module are deprecated and will be removed in a future release. "
+    "Please use the methods in desdeo.emo.methods.templates instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

desdeo/emo/methods/templates.py

@@ -0,0 +1,111 @@
+"""This module contains the basic functional implementations for the EMO methods.
+
+This can be used as a template for the implementation of the EMO methods.
+"""
+
+from collections.abc import Callable
+
+import polars as pl
+from pydantic import BaseModel, ConfigDict, Field
+
+from desdeo.emo.operators.crossover import BaseCrossover
+from desdeo.emo.operators.evaluator import EMOEvaluator
+from desdeo.emo.operators.generator import BaseGenerator
+from desdeo.emo.operators.mutation import BaseMutation
+from desdeo.emo.operators.scalar_selection import BaseScalarSelector
+from desdeo.emo.operators.selection import BaseSelector
+from desdeo.emo.operators.termination import BaseTerminator
+from desdeo.tools.generics import EMOResult
+
+
+def template1(
+    evaluator: EMOEvaluator,
+    crossover: BaseCrossover,
+    mutation: BaseMutation,
+    generator: BaseGenerator,
+    selection: BaseSelector,
+    terminator: BaseTerminator,
+    repair: Callable[[pl.DataFrame], pl.DataFrame] = lambda x: x,  # Default to identity function if no repair is needed
+) -> EMOResult:
+    """Implements a template that many EMO methods, such as RVEA and NSGA-III, follow.
+
+    Args:
+        evaluator (EMOEvaluator): A class that evaluates the solutions and provides the objective vectors, constraint
+            vectors, and targets.
+        crossover (BaseCrossover): The crossover operator.
+        mutation (BaseMutation): The mutation operator.
+        generator (BaseGenerator): A class that generates the initial population.
+        selection (BaseSelector): The selection operator.
+        terminator (BaseTerminator): The termination operator.
+        repair (Callable, optional): A function that repairs the offspring if they go out of bounds. Defaults to an
+            identity function, meaning no repair is done. See :py:func:`desdeo.tools.utils.repair` as an example of a
+            repair function.
+
+    Returns:
+        EMOResult: The final population and their objective vectors, constraint vectors, and targets
+    """
+    solutions, outputs = generator.do()
+
+    while not terminator.check():
+        offspring = crossover.do(population=solutions)
+        offspring = mutation.do(offspring, solutions)
+        # Repair offspring if they go out of bounds
+        offspring = repair(offspring)
+        offspring_outputs = evaluator.evaluate(offspring)
+        solutions, outputs = selection.do(parents=(solutions, outputs), offsprings=(offspring, offspring_outputs))
+
+    return EMOResult(optimal_variables=solutions, optimal_outputs=outputs)
+
+
+def template2(
+    evaluator: EMOEvaluator,
+    crossover: BaseCrossover,
+    mutation: BaseMutation,
+    generator: BaseGenerator,
+    selection: BaseSelector,
+    mate_selection: BaseScalarSelector,
+    terminator: BaseTerminator,
+    repair: Callable[[pl.DataFrame], pl.DataFrame] = lambda x: x,  # Default to identity function if no repair is needed
+) -> EMOResult:
+    """Implements a template that many EMO methods, such as IBEA, follow.
+
+    Args:
+        evaluator (EMOEvaluator): A class that evaluates the solutions and provides the objective vectors, constraint
+            vectors, and targets.
+        crossover (BaseCrossover): The crossover operator.
+        mutation (BaseMutation): The mutation operator.
+        generator (BaseGenerator): A class that generates the initial population.
+        selection (BaseSelector): The selection operator.
+        mate_selection (BaseScalarSelector): The mating selection operator, which selects parents for mating.
+            This is typically a scalar selector that selects parents based on their fitness.
+        terminator (BaseTerminator): The termination operator.
+        repair (Callable, optional): A function that repairs the offspring if they go out of bounds. Defaults to an
+            identity function, meaning no repair is done. See :py:func:`desdeo.tools.utils.repair` as an example of a
+            repair function.
+
+    Returns:
+        EMOResult: The final population and their objective vectors, constraint vectors, and targets
+    """
+    solutions, outputs = generator.do()
+    # This is just a hack to make all selection operators work (they require offsprings to be passed separately rn)
+    offspring = pl.DataFrame(
+        schema=solutions.schema,
+    )
+    offspring_outputs = pl.DataFrame(
+        schema=outputs.schema,
+    )
+
+    while True:
+        solutions, outputs = selection.do(parents=(solutions, outputs), offsprings=(offspring, offspring_outputs))
+        if terminator.check():
+            # Weird way to do looping, but IBEA does environmental selection before the loop check, and...
+            # does mating afterwards.
+            break
+        parents, _ = mate_selection.do((solutions, outputs))
+        offspring = crossover.do(population=parents)
+        offspring = mutation.do(offspring, solutions)
+        # Repair offspring if they go out of bounds
+        offspring = repair(offspring)
+        offspring_outputs = evaluator.evaluate(offspring)
+
+    return EMOResult(optimal_variables=solutions, optimal_outputs=outputs)