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

desdeo/emo/hooks/archivers.py

@@ -0,0 +1,172 @@
+"""A collection of archivers for storing solutions evaluated during evolution."""
+
+from collections.abc import Sequence
+
+import polars as pl
+
+from desdeo.problem import Problem
+from desdeo.tools.message import (
+    EvaluatorMessageTopics,
+    GeneratorMessageTopics,
+    Message,
+    MessageTopics,
+    SelectorMessageTopics,
+    TerminatorMessageTopics,
+)
+from desdeo.tools.non_dominated_sorting import non_dominated, non_dominated_merge
+from desdeo.tools.patterns import Publisher, Subscriber
+
+
+class BaseArchive(Subscriber):
+    """Base class for archivers."""
+
+    @property
+    def interested_topics(self) -> Sequence[MessageTopics]:
+        """Return the message topics that the archiver is interested in."""
+        return [
+            GeneratorMessageTopics.VERBOSE_OUTPUTS,
+            EvaluatorMessageTopics.VERBOSE_OUTPUTS,
+            SelectorMessageTopics.SELECTED_VERBOSE_OUTPUTS,
+            TerminatorMessageTopics.GENERATION,
+        ]
+
+    @property
+    def provided_topics(self) -> dict[int, Sequence[MessageTopics]]:
+        """Return the topics provided by the archiver."""
+        return {0: []}
+
+    def __init__(self, *, problem: Problem, publisher: Publisher):
+        """Initialize the base archiver.
+
+        Args:
+            problem (Problem): The problem being solved.
+            publisher (Publisher): The publisher object.
+        """
+        super().__init__(publisher, verbosity=0)
+        self.solutions: pl.DataFrame = None
+        self.selections: pl.DataFrame = None
+        self.problem = problem
+        self.generation_number = 1
+
+    def state(self) -> Sequence[Message]:
+        """Return the state of the archiver."""
+        return []
+
+    def update(self, message: Message) -> None:
+        """Updae the archiver with new data.
+
+        Takes care of common archiving jobs. Make sure to run this for every archiver.
+
+        Args:
+            message (Message): Message from the publisher.
+        """
+        if message.topic == TerminatorMessageTopics.GENERATION:
+            self.generation_number = message.value
+            return
+        if message.topic == SelectorMessageTopics.SELECTED_VERBOSE_OUTPUTS:
+            data: pl.DataFrame = message.value
+            data = data.with_columns(generation=self.generation_number)
+            if self.selections is None:
+                self.selections = data
+            else:
+                self.selections = pl.concat([self.selections, data], how="vertical")
+            return
+
+
+class FeasibleArchive(BaseArchive):
+    """An archiver that stores all feasible solutions evaluated during evolution."""
+
+    def __init__(self, *, problem: Problem, publisher: Publisher):
+        """Initialize the archiver.
+
+        Args:
+            problem (Problem): The problem being solved.
+            publisher (Publisher): The publisher object.
+        """
+        super().__init__(problem=problem, publisher=publisher)
+
+        if problem.constraints is None:
+            raise ValueError("The problem has no constraints.")
+        self.cons_symb = [x.symbol for x in problem.constraints]
+
+    def update(self, message: Message) -> None:
+        """Update the archiver with the new data.
+
+        Args:
+            message (Message): Message from the publisher.
+        """
+        if (
+            message.topic == TerminatorMessageTopics.GENERATION  # NOQA: PLR1714
+            or message.topic == SelectorMessageTopics.SELECTED_VERBOSE_OUTPUTS
+        ):
+            super().update(message)
+            return
+        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)
+        if self.solutions is None:
+            self.solutions = feasible_data
+        else:
+            self.solutions = pl.concat([self.solutions, feasible_data])
+
+
+class Archive(BaseArchive):
+    """An archiver that stores the solutions evaluated during evolution."""
+
+    def update(self, message: Message) -> None:
+        """Update the archiver with the new data.
+
+        Args:
+            message (Message): Message from the publisher.
+        """
+        if (
+            message.topic == TerminatorMessageTopics.GENERATION  # NOQA: PLR1714
+            or message.topic == SelectorMessageTopics.SELECTED_VERBOSE_OUTPUTS
+        ):
+            super().update(message)
+            return
+        data = message.value
+        data = data.with_columns(generation=self.generation_number)
+        if self.solutions is None:
+            self.solutions = data
+        else:
+            self.solutions = pl.concat([self.solutions, data])
+
+
+class NonDominatedArchive(Archive):
+    """An archiver that stores only the non-dominated solutions evaluated during evolution."""
+
+    def __init__(self, *, problem: Problem, publisher: Publisher):
+        """Initialize the archiver.
+
+        Args:
+            problem (Problem): The problem being solved.
+            publisher (Publisher): The publisher object.
+        """
+        super().__init__(problem=problem, publisher=publisher)
+        self.targets = [f"{x.symbol}_min" for x in problem.objectives]
+
+    def update(self, message: Message) -> None:
+        """Update the archiver with the new data.
+
+        Args:
+            message (Message): Message from the publisher.
+        """
+        if (
+            message.topic == TerminatorMessageTopics.GENERATION  # NOQA: PLR1714
+            or message.topic == SelectorMessageTopics.SELECTED_VERBOSE_OUTPUTS
+        ):
+            super().update(message)
+            return
+        data = message.value
+        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.solutions is None:
+            non_dom_mask = non_dominated(data[self.targets].to_numpy())
+            self.solutions = data.filter(non_dom_mask)
+        else:
+            to_add = data.filter(non_dominated(data[self.targets].to_numpy()))
+            mask1, mask2 = non_dominated_merge(self.solutions[self.targets].to_numpy(), to_add[self.targets].to_numpy())
+            self.solutions = pl.concat([self.solutions.filter(mask1), to_add.filter(mask2)])

desdeo/emo/methods/EAs.py

@@ -0,0 +1,418 @@
+"""Implements common evolutionary algorithms for multi-objective optimization."""
+
+from collections.abc import Callable
+from functools import partial
+
+from desdeo.emo.methods.bases import EMOResult, template1
+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.termination import MaxEvaluationsTerminator, MaxGenerationsTerminator
+from desdeo.problem import Problem
+from desdeo.tools.patterns import Publisher
+
+
+def rvea(
+    *,
+    problem: Problem,
+    seed: int = 0,
+    n_generations=100,
+    max_evaluations: int | None = None,
+    reference_vector_options: ReferenceVectorOptions = None,
+    forced_verbosity: int | None = None,
+) -> tuple[Callable[[], EMOResult], Publisher]:
+    """Implements the Reference Vector Guided Evolutionary Algorithm (RVEA), as well as its interactive version.
+
+    References:
+        R. Cheng, Y. Jin, M. Olhofer and B. Sendhoff, "A Reference Vector Guided Evolutionary Algorithm for Many-
+        Objective Optimization," in IEEE Transactions on Evolutionary Computation, vol. 20, no. 5, pp. 773-791,
+        Oct. 2016, doi: 10.1109/TEVC.2016.2519378.
+
+        J. Hakanen, T. Chugh, K. Sindhya, Y. Jin, and K. Miettinen, “Connections of reference vectors and different
+        types of preference information in interactive multiobjective evolutionary algorithms,” in 2016 IEEE Symposium
+        Series on Computational Intelligence (SSCI), Athens, Greece: IEEE, Dec. 2016, pp. 1-8.
+
+
+    Args:
+        problem (Problem): The problem to be solved.
+        seed (int, optional): The seed for the random number generator. Defaults to 0.
+        n_generations (int, optional): The number of generations to run the algorithm. Defaults to 100.
+        max_evaluations (int, 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.
+        reference_vector_options (ReferenceVectorOptions, optional): The options for the reference vectors. Defaults to
+            None. See the ReferenceVectorOptions class for the defaults. This option can be used to run an interactive
+            version of the algorithm, using preferences provided by the user.
+        forced_verbosity (int, 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 = RVEASelector(
+        problem=problem,
+        publisher=publisher,
+        reference_vector_options=reference_vector_options,
+        verbosity=forced_verbosity if forced_verbosity is not None else 2,
+    )
+
+    # Note that the initial population size is equal to the number of reference vectors
+    n_points = selector.reference_vectors.shape[0]
+
+    generator = LHSGenerator(
+        problem=problem,
+        evaluator=evaluator,
+        publisher=publisher,
+        n_points=n_points,
+        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)
+
+    components = [evaluator, generator, crossover, mutation, selector, terminator]
+    [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(
+            template1,
+            evaluator=evaluator,
+            crossover=crossover,
+            mutation=mutation,
+            generator=generator,
+            selection=selector,
+            terminator=terminator,
+        ),
+        publisher,
+    )
+
+
+def nsga3(
+    *,
+    problem: Problem,
+    seed: int = 0,
+    n_generations: int = 100,
+    max_evaluations: int | None = None,
+    reference_vector_options: ReferenceVectorOptions = None,
+    forced_verbosity: int | None = None,
+) -> tuple[Callable[[], EMOResult], Publisher]:
+    """Implements the NSGA-III algorithm as well as its interactive version.
+
+    References:
+        K. Deb and H. Jain, “An Evolutionary Many-Objective Optimization Algorithm Using Reference-Point-Based
+        Nondominated Sorting Approach, Part I: Solving Problems With Box Constraints,” IEEE Transactions on Evolutionary
+        Computation, vol. 18, no. 4, pp. 577-601, Aug. 2014.
+
+        J. Hakanen, T. Chugh, K. Sindhya, Y. Jin, and K. Miettinen, “Connections of reference vectors and different
+        types of preference information in interactive multiobjective evolutionary algorithms,” in 2016 IEEE Symposium
+        Series on Computational Intelligence (SSCI), Athens, Greece: IEEE, Dec. 2016, pp. 1-8.
+
+    Args:
+        problem (Problem): The problem to be solved.
+        seed (int, optional): The seed for the random number generator. Defaults to 0.
+        n_generations (int, optional): The number of generations to run the algorithm. Defaults to 100.
+        max_evaluations (int, 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.
+        reference_vector_options (ReferenceVectorOptions, optional): The options for the reference vectors. Defaults to
+            None. See the ReferenceVectorOptions class for the defaults. This option can be used to run an interactive
+            version of the algorithm, using preferences provided by the user.
+        forced_verbosity (int, 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 = NSGAIII_select(
+        problem=problem,
+        publisher=publisher,
+        verbosity=forced_verbosity if forced_verbosity is not None else 2,
+        reference_vector_options=reference_vector_options,
+    )
+
+    # Note that the initial population size is equal to the number of reference vectors
+    n_points = selector.reference_vectors.shape[0]
+
+    generator = LHSGenerator(
+        problem=problem,
+        evaluator=evaluator,
+        publisher=publisher,
+        n_points=n_points,
+        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,
+        )
+
+    components = [evaluator, generator, crossover, mutation, selector, terminator]
+    [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(
+            template1,
+            evaluator=evaluator,
+            crossover=crossover,
+            mutation=mutation,
+            generator=generator,
+            selection=selector,
+            terminator=terminator,
+        ),
+        publisher,
+    )
+
+
+def nsga3_mixed_integer(
+    *,
+    problem: Problem,
+    seed: int = 0,
+    n_generations: int = 100,
+    max_evaluations: int | None = None,
+    reference_vector_options: ReferenceVectorOptions = None,
+    forced_verbosity: int | None = None,
+) -> tuple[Callable[[], EMOResult], Publisher]:
+    """Implements the NSGA-III algorithm as well as its interactive version for mixed-integer problems.
+
+    References:
+        K. Deb and H. Jain, “An Evolutionary Many-Objective Optimization Algorithm Using Reference-Point-Based
+        Nondominated Sorting Approach, Part I: Solving Problems With Box Constraints,” IEEE Transactions on Evolutionary
+        Computation, vol. 18, no. 4, pp. 577-601, Aug. 2014.
+
+        J. Hakanen, T. Chugh, K. Sindhya, Y. Jin, and K. Miettinen, “Connections of reference vectors and different
+        types of preference information in interactive multiobjective evolutionary algorithms,” in 2016 IEEE Symposium
+        Series on Computational Intelligence (SSCI), Athens, Greece: IEEE, Dec. 2016, pp. 1-8.
+
+    Args:
+        problem (Problem): The problem to be solved.
+        seed (int, optional): The seed for the random number generator. Defaults to 0.
+        n_generations (int, optional): The number of generations to run the algorithm. Defaults to 100.
+        max_evaluations (int, 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.
+        reference_vector_options (ReferenceVectorOptions, optional): The options for the reference vectors. Defaults to
+            None. See the ReferenceVectorOptions class for the defaults. This option can be used to run an interactive
+            version of the algorithm, using preferences provided by the user.
+        forced_verbosity (int, 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 = NSGAIII_select(
+        problem=problem,
+        publisher=publisher,
+        verbosity=forced_verbosity if forced_verbosity is not None else 2,
+        reference_vector_options=reference_vector_options,
+    )
+
+    # Note that the initial population size is equal to the number of reference vectors
+    n_points = selector.reference_vectors.shape[0]
+
+    generator = RandomMixedIntegerGenerator(
+        problem=problem,
+        evaluator=evaluator,
+        publisher=publisher,
+        n_points=n_points,
+        seed=seed,
+        verbosity=forced_verbosity if forced_verbosity is not None else 1,
+    )
+    crossover = UniformMixedIntegerCrossover(
+        problem=problem,
+        publisher=publisher,
+        seed=seed,
+        verbosity=forced_verbosity if forced_verbosity is not None else 1,
+    )
+    mutation = MixedIntegerRandomMutation(
+        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,
+        )
+
+    components = [evaluator, generator, crossover, mutation, selector, terminator]
+    [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(
+            template1,
+            evaluator=evaluator,
+            crossover=crossover,
+            mutation=mutation,
+            generator=generator,
+            selection=selector,
+            terminator=terminator,
+        ),
+        publisher,
+    )
+
+
+def rvea_mixed_integer(
+    *,
+    problem: Problem,
+    seed: int = 0,
+    n_generations=100,
+    max_evaluations: int | None = None,
+    reference_vector_options: ReferenceVectorOptions = None,
+    forced_verbosity: int | None = None,
+) -> tuple[Callable[[], EMOResult], Publisher]:
+    """Implements the mixed-integer variant of RVEA, as well as its interactive version.
+
+    References:
+        R. Cheng, Y. Jin, M. Olhofer and B. Sendhoff, "A Reference Vector Guided Evolutionary Algorithm for Many-
+        Objective Optimization," in IEEE Transactions on Evolutionary Computation, vol. 20, no. 5, pp. 773-791,
+        Oct. 2016, doi: 10.1109/TEVC.2016.2519378.
+
+        J. Hakanen, T. Chugh, K. Sindhya, Y. Jin, and K. Miettinen, “Connections of reference vectors and different
+        types of preference information in interactive multiobjective evolutionary algorithms,” in 2016 IEEE Symposium
+        Series on Computational Intelligence (SSCI), Athens, Greece: IEEE, Dec. 2016, pp. 1-8.
+
+
+    Args:
+        problem (Problem): The problem to be solved.
+        seed (int, optional): The seed for the random number generator. Defaults to 0.
+        n_generations (int, optional): The number of generations to run the algorithm. Defaults to 100.
+        max_evaluations (int, 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.
+        reference_vector_options (ReferenceVectorOptions, optional): The options for the reference vectors. Defaults to
+            None. See the ReferenceVectorOptions class for the defaults. This option can be used to run an interactive
+            version of the algorithm, using preferences provided by the user.
+        forced_verbosity (int, 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 = RVEASelector(
+        problem=problem,
+        publisher=publisher,
+        reference_vector_options=reference_vector_options,
+        verbosity=forced_verbosity if forced_verbosity is not None else 2,
+    )
+
+    # Note that the initial population size is equal to the number of reference vectors
+    n_points = selector.reference_vectors.shape[0]
+
+    generator = RandomMixedIntegerGenerator(
+        problem=problem,
+        evaluator=evaluator,
+        publisher=publisher,
+        n_points=n_points,
+        seed=seed,
+        verbosity=forced_verbosity if forced_verbosity is not None else 1,
+    )
+    crossover = UniformMixedIntegerCrossover(
+        problem=problem,
+        publisher=publisher,
+        seed=seed,
+        verbosity=forced_verbosity if forced_verbosity is not None else 1,
+    )
+    mutation = MixedIntegerRandomMutation(
+        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)
+
+    components = [evaluator, generator, crossover, mutation, selector, terminator]
+    [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(
+            template1,
+            evaluator=evaluator,
+            crossover=crossover,
+            mutation=mutation,
+            generator=generator,
+            selection=selector,
+            terminator=terminator,
+        ),
+        publisher,
+    )

desdeo/emo/methods/bases.py

@@ -0,0 +1,59 @@
+"""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.
+"""
+
+import numpy as np
+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.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)

desdeo/emo/operators/__init__.py

@@ -0,0 +1 @@
+