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

desdeo/emo/options/generator.py

@@ -0,0 +1,131 @@
+"""JSON Schema for generator options."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import polars as pl
+from pydantic import BaseModel, Field
+
+from desdeo.emo.operators.evaluator import EMOEvaluator
+from desdeo.emo.operators.generator import (
+    ArchiveGenerator,
+    BaseGenerator,
+    LHSGenerator,
+    RandomBinaryGenerator,
+    RandomGenerator,
+    RandomIntegerGenerator,
+    RandomMixedIntegerGenerator,
+)
+
+if TYPE_CHECKING:
+    from desdeo.problem import Problem
+    from desdeo.tools.patterns import Publisher
+
+
+class BaseGeneratorOptions(BaseModel):
+    """Options for all generators."""
+
+    n_points: int = Field(gt=0, description="The number of points to generate for the initial population.")
+    """The number of points to generate for the initial population."""
+
+
+class LHSGeneratorOptions(BaseGeneratorOptions):
+    """Options for Latin Hypercube Sampling (LHS) generator."""
+
+    name: Literal["LHSGenerator"] = Field(default="LHSGenerator", frozen=True, description="The name of the generator.")
+    """The name of the generator."""
+
+
+class RandomBinaryGeneratorOptions(BaseGeneratorOptions):
+    """Options for Random Binary generator."""
+
+    name: Literal["RandomBinaryGenerator"] = Field(
+        default="RandomBinaryGenerator", frozen=True, description="The name of the generator."
+    )
+    """The name of the generator."""
+
+
+class RandomGeneratorOptions(BaseGeneratorOptions):
+    """Options for Random generator."""
+
+    name: Literal["RandomGenerator"] = Field(
+        default="RandomGenerator", frozen=True, description="The name of the generator."
+    )
+    """The name of the generator."""
+
+
+class RandomIntegerGeneratorOptions(BaseGeneratorOptions):
+    """Options for Random Integer generator."""
+
+    name: Literal["RandomIntegerGenerator"] = Field(
+        default="RandomIntegerGenerator", frozen=True, description="The name of the generator."
+    )
+    """The name of the generator."""
+
+
+class RandomMixedIntegerGeneratorOptions(BaseGeneratorOptions):
+    """Options for Random Mixed Integer generator."""
+
+    name: Literal["RandomMixedIntegerGenerator"] = Field(
+        default="RandomMixedIntegerGenerator", frozen=True, description="The name of the generator."
+    )
+    """The name of the generator."""
+
+
+class ArchiveGeneratorOptions(BaseModel):
+    """Options for Archive generator."""
+
+    model_config = {"arbitrary_types_allowed": True, "use_attribute_docstrings": True}
+
+    name: Literal["ArchiveGenerator"] = "ArchiveGenerator"
+    """The name of the generator."""
+    solutions: pl.DataFrame
+    """The initial solutions to populate the archive with."""
+    outputs: pl.DataFrame
+    """The corresponding outputs of the initial solutions."""
+
+GeneratorOptions = (
+    LHSGeneratorOptions
+    | RandomBinaryGeneratorOptions
+    | RandomGeneratorOptions
+    | RandomIntegerGeneratorOptions
+    | RandomMixedIntegerGeneratorOptions
+    | ArchiveGeneratorOptions
+)
+
+
+def generator_constructor(
+    problem: Problem,
+    options: GeneratorOptions,
+    publisher: Publisher,
+    verbosity: int,
+    seed: int,
+    evaluator: EMOEvaluator,
+) -> BaseGenerator:
+    """Construct a generator based on the provided options.
+
+    Args:
+        problem (Problem): The optimization problem to solve.
+        options (GeneratorOptions): The options for the generator.
+        publisher (Publisher): The publisher for the generator.
+        verbosity (int): The verbosity level for the generator.
+        seed (int): The random seed for the generator.
+        evaluator (EMOEvaluator): The evaluator to use for evaluating solutions.
+
+    Returns:
+        BaseGenerator: The constructed generator.
+    """
+    generator_types = {
+        "LHSGenerator": LHSGenerator,
+        "RandomBinaryGenerator": RandomBinaryGenerator,
+        "RandomGenerator": RandomGenerator,
+        "RandomIntegerGenerator": RandomIntegerGenerator,
+        "RandomMixedIntegerGenerator": RandomMixedIntegerGenerator,
+        "ArchiveGenerator": ArchiveGenerator,
+    }
+    options: dict = options.model_dump()
+    name = options.pop("name")
+    return generator_types[name](
+        problem, **options, publisher=publisher, verbosity=verbosity, seed=seed, evaluator=evaluator
+    )

desdeo/emo/options/mutation.py

@@ -0,0 +1,260 @@
+"""JSON Schema for mutation operator options."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel, Field
+
+from desdeo.emo.operators.mutation import (
+    BaseMutation,
+    BinaryFlipMutation,
+    BoundedPolynomialMutation,
+    IntegerRandomMutation,
+    MixedIntegerRandomMutation,
+    MPTMutation,
+    NonUniformMutation,
+    PowerMutation,
+    SelfAdaptiveGaussianMutation,
+)
+
+if TYPE_CHECKING:
+    from desdeo.problem import Problem
+    from desdeo.tools.patterns import Publisher
+
+
+class BoundedPolynomialMutationOptions(BaseModel):
+    """Options for Bounded Polynomial Mutation."""
+
+    model_config = {"use_attribute_docstrings": True}
+
+    name: Literal["BoundedPolynomialMutation"] = Field(
+        default="BoundedPolynomialMutation",
+        frozen=True,
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(default=None, ge=0.0, le=1.0)
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+    distribution_index: float = Field(default=20.0, gt=0.0)
+    """The distribution index."""
+
+
+class BinaryFlipMutationOptions(BaseModel):
+    """Options for Binary Flip Mutation."""
+
+    name: Literal["BinaryFlipMutation"] = Field(
+        default="BinaryFlipMutation", frozen=True, description="The name of the mutation operator."
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The probability of mutation. Defaults to None, which sets the "
+            "mutation probability to 1/<number of decision variables>."
+        ),
+    )
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+
+
+class IntegerRandomMutationOptions(BaseModel):
+    """Options for Integer Random Mutation."""
+
+    name: Literal["IntegerRandomMutation"] = Field(
+        default="IntegerRandomMutation", frozen=True, description="The name of the mutation operator."
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The probability of mutation. Defaults to None, which sets the "
+            "mutation probability to 1/<number of decision variables>."
+        ),
+    )
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+
+
+class MixedIntegerRandomMutationOptions(BaseModel):
+    """Options for Mixed Integer Random Mutation."""
+
+    name: Literal["MixedIntegerRandomMutation"] = Field(
+        default="MixedIntegerRandomMutation", frozen=True, description="The name of the mutation operator."
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The probability of mutation. Defaults to None, which sets the "
+            "mutation probability to 1/<number of decision variables>."
+        ),
+    )
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+
+
+class MPTMutationOptions(BaseModel):
+    """Options for MPT Mutation."""
+
+    name: Literal["MPTMutation"] = Field(
+        default="MPTMutation", frozen=True, description="The name of the mutation operator."
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The probability of mutation. Defaults to None, which sets the "
+            "mutation probability to 1/<number of decision variables>."
+        ),
+    )
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+    mutation_exponent: float = Field(
+        default=2.0, ge=0.0, description="Controls strength of small mutation (larger means smaller mutations)."
+    )
+    """Controls strength of small mutation (larger means smaller mutations)."""
+
+
+class NonUniformMutationOptions(BaseModel):
+    """Options for Non-Uniform Mutation."""
+
+    name: Literal["NonUniformMutation"] = Field(
+        default="NonUniformMutation", frozen=True, description="The name of the mutation operator."
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The probability of mutation. Defaults to None, which sets the "
+            "mutation probability to 1/<number of decision variables>."
+        ),
+    )
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+    max_generations: int = Field(
+        gt=0, description="Maximum number of generations in the evolutionary run. Used to scale mutation decay."
+    )
+    b: float = Field(
+        default=5.0,
+        ge=0.0,
+        description=(
+            "Non-uniform mutation decay parameter. Higher values cause"
+            "faster reduction in mutation strength over generations."
+        ),
+    )
+    """Non-uniform mutation decay parameter. Higher values cause
+    faster reduction in mutation strength over generations."""
+
+
+class SelfAdaptiveGaussianMutationOptions(BaseModel):
+    """Options for Self-Adaptive Gaussian Mutation."""
+
+    name: Literal["SelfAdaptiveGaussianMutation"] = Field(
+        default="SelfAdaptiveGaussianMutation", frozen=True, description="The name of the mutation operator."
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The probability of mutation. Defaults to None, which sets the "
+            "mutation probability to 1/<number of decision variables>."
+        ),
+    )
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+
+
+class PowerMutationOptions(BaseModel):
+    """Options for Power Mutation."""
+
+    name: Literal["PowerMutation"] = Field(
+        default="PowerMutation", frozen=True, description="The name of the mutation operator."
+    )
+    """The name of the mutation operator."""
+    mutation_probability: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The probability of mutation. Defaults to None, which sets the "
+            "mutation probability to 1/<number of decision variables>."
+        ),
+    )
+    """
+    The probability of mutation. Defaults to None, which sets the mutation probability to
+    1/<number of decision variables>.
+    """
+    p: float = Field(
+        default=1.5, ge=0.0, description="Power distribution parameter. Controls the perturbation magnitude."
+    )
+    """Power distribution parameter. Controls the perturbation magnitude."""
+
+
+MutationOptions = (
+    BoundedPolynomialMutationOptions
+    | BinaryFlipMutationOptions
+    | IntegerRandomMutationOptions
+    | MixedIntegerRandomMutationOptions
+    | MPTMutationOptions
+    | NonUniformMutationOptions
+    | SelfAdaptiveGaussianMutationOptions
+    | PowerMutationOptions
+)
+"""All possible mutation operator options."""
+
+
+def mutation_constructor(
+    problem: Problem, publisher: Publisher, seed: int, verbosity: int, options: MutationOptions
+) -> BaseMutation:
+    """Construct a mutation operator.
+
+    Args:
+        problem (Problem): The optimization problem to solve.
+        publisher (Publisher): The publisher for communication.
+        seed (int): The random seed for reproducibility.
+        verbosity (int): The verbosity level of the output.
+        options (MutationOptions): The options for the mutation operator.
+
+    Returns:
+        BaseCrossover: The constructed crossover operator.
+    """
+    mutation_types = {
+        "BoundedPolynomialMutation": BoundedPolynomialMutation,
+        "BinaryFlipMutation": BinaryFlipMutation,
+        "IntegerRandomMutation": IntegerRandomMutation,
+        "MixedIntegerRandomMutation": MixedIntegerRandomMutation,
+        "MPTMutation": MPTMutation,
+        "NonUniformMutation": NonUniformMutation,
+        "SelfAdaptiveGaussianMutation": SelfAdaptiveGaussianMutation,
+        "PowerMutation": PowerMutation,
+    }
+    options: dict = options.model_dump()
+    name = options.pop("name")
+    return mutation_types[name](problem=problem, publisher=publisher, seed=seed, verbosity=verbosity, **options)

desdeo/emo/options/repair.py

@@ -0,0 +1,61 @@
+"""JSON Schema for repair operator options."""
+
+from collections.abc import Callable
+from typing import Literal
+
+import polars as pl
+from pydantic import BaseModel, ConfigDict, Field
+
+from desdeo.problem import Problem
+from desdeo.tools.utils import repair
+
+
+class NoRepairOptions(BaseModel):
+    """Options for No Repair."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    name: Literal["NoRepair"] = Field(default="NoRepair")
+    """Do not apply any repair to the solutions."""
+
+
+class ClipRepairOptions(BaseModel):
+    """Options for Clip Repair."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    name: Literal["ClipRepair"] = Field(default="ClipRepair")
+    """Clip the solutions to be within the variable bounds."""
+
+    lower_bounds: dict[str, float] | None = None
+    """Lower bounds for the decision variables. If none, the lower bounds from the problem will be used."""
+    upper_bounds: dict[str, float] | None = None
+    """Upper bounds for the decision variables. If none, the upper bounds from the problem will be used."""
+
+
+RepairOptions = ClipRepairOptions | NoRepairOptions
+
+
+def repair_constructor(options: RepairOptions, problem: Problem) -> Callable[[pl.DataFrame], pl.DataFrame]:
+    """Get the repair operator based on the provided options.
+
+    Args:
+        options (RepairOptions): The repair options.
+        problem (Problem): The optimization problem to solve.
+
+    Returns:
+        callable: The repair operator function.
+    """
+    if options.name == "NoRepair":
+        return lambda x: x  # No repair, return input as is
+    if options.name == "ClipRepair":
+        if options.lower_bounds is None:
+            lower_bounds = {var.symbol: var.lowerbound for var in problem.get_flattened_variables()}
+        else:
+            lower_bounds = options.lower_bounds
+        if options.upper_bounds is None:
+            upper_bounds = {var.symbol: var.upperbound for var in problem.get_flattened_variables()}
+        else:
+            upper_bounds = options.upper_bounds
+        return repair(lower_bounds=lower_bounds, upper_bounds=upper_bounds)
+    raise ValueError(f"Unknown repair operator: {options.name}")

desdeo/emo/options/scalar_selection.py

@@ -0,0 +1,66 @@
+"""JSON Schema for scalar selector operator options."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel, Field
+
+from desdeo.emo.operators.scalar_selection import BaseScalarSelector, TournamentSelection
+
+if TYPE_CHECKING:
+    from desdeo.tools.patterns import Publisher
+
+
+class TournamentSelectionOptions(BaseModel):
+    """Options for tournament selection operator."""
+
+    name: Literal["TournamentSelection"] = Field(
+        default="TournamentSelection", frozen=True, description="The name of the scalar selection operator."
+    )
+    """The name of the scalar selection operator."""
+    tournament_size: int = Field(
+        default=2,
+        description="The number of individuals participating in the tournament.",
+    )
+    """The number of individuals participating in the tournament."""
+    winner_size: int = Field(
+        gt=1,
+        description="The number of winners to select (equivalent to population size).",
+    )
+    """The number of winners to select (equivalent to population size)."""
+
+
+class RouletteWheelSelectionOptions(TournamentSelectionOptions):
+    """Options for roulette wheel selection operator."""
+
+    name: Literal["RouletteWheelSelection"] = Field(
+        default="RouletteWheelSelection", frozen=True, description="The name of the scalar selection operator."
+    )
+    """The name of the scalar selection operator."""
+
+
+ScalarSelectionOptions = TournamentSelectionOptions | RouletteWheelSelectionOptions
+
+
+def scalar_selector_constructor(
+    options: ScalarSelectionOptions, seed: int, publisher: Publisher, verbosity: int
+) -> BaseScalarSelector:
+    """Construct a scalar selector operator based on the provided options."""
+    if options.name == "TournamentSelection":
+        return TournamentSelection(
+            tournament_size=options.tournament_size,
+            winner_size=options.winner_size,
+            publisher=publisher,
+            verbosity=verbosity,
+        )
+    if options.name == "RouletteWheelSelection":
+        return TournamentSelection(  # It implements both (and more)
+            winner_size=options.winner_size,
+            seed=seed,  # By providing seed tournament selection behaves like roulette wheel
+            publisher=publisher,
+            verbosity=verbosity,
+            tournament_size=options.tournament_size,
+        )
+    else:
+        raise ValueError(f"Unknown scalar selection operator: {options.name}")

desdeo/emo/options/selection.py

@@ -0,0 +1,127 @@
+"""JSON Schema for selection operator options."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from desdeo.emo.operators.selection import (
+    BaseSelector,
+    IBEASelector,
+    NSGA2Selector,
+    NSGA3Selector,
+    ParameterAdaptationStrategy,
+    ReferenceVectorOptions,
+    RVEASelector,
+)
+from desdeo.tools.indicators_binary import self_epsilon, self_hv
+
+if TYPE_CHECKING:
+    from desdeo.problem import Problem
+    from desdeo.tools.patterns import Publisher
+
+
+class RVEASelectorOptions(BaseModel):
+    """Options for RVEA Selection."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    name: Literal["RVEASelector"] = Field(
+        default="RVEASelector", frozen=True, description="The name of the selection operator."
+    )
+    """The name of the selection operator."""
+    reference_vector_options: ReferenceVectorOptions = Field(
+        default=ReferenceVectorOptions(), description="Options for the reference vectors."
+    )
+    """Options for the reference vectors."""
+    parameter_adaptation_strategy: ParameterAdaptationStrategy = Field(
+        default=ParameterAdaptationStrategy.GENERATION_BASED, description="The parameter adaptation strategy to use."
+    )
+    """Whether the angle penalized distance is adapted per generation or per function evaluation."""
+    alpha: float = Field(default=2.0, gt=0.0, description="The alpha parameter in the angle penalized distance.")
+    """The alpha parameter in the angle penalized distance."""
+
+
+class NSGA3SelectorOptions(BaseModel):
+    """Options for NSGA-III Selection."""
+
+    name: Literal["NSGA3Selector"] = Field(
+        default="NSGA3Selector", frozen=True, description="The name of the selection operator."
+    )
+    """The name of the selection operator."""
+    reference_vector_options: ReferenceVectorOptions = Field(
+        default=ReferenceVectorOptions(), description="Options for the reference vectors."
+    )
+    """Options for the reference vectors."""
+    invert_reference_vectors: bool = Field(
+        default=False, description="Whether to invert the reference vectors (inverted triangle)."
+    )
+    """Whether to invert the reference vectors (inverted triangle)."""
+
+
+class NSGA2SelectorOptions(BaseModel):
+    """Options for NSGA-II Selection."""
+
+    name: Literal["NSGA2Selector"] = Field(
+        default="NSGA2Selector", frozen=True, description="The name of the selection operator."
+    )
+    """The name of the selection operator."""
+    population_size: int = Field(gt=0, description="The population size.")
+    """The population size."""
+
+
+class IBEASelectorOptions(BaseModel):
+    """Options for IBEA Selection."""
+
+    name: Literal["IBEASelector"] = Field(
+        default="IBEASelector", frozen=True, description="The name of the selection operator."
+    )
+    """The name of the selection operator."""
+    population_size: int = Field(gt=0, description="The population size.")
+    """The population size."""
+    kappa: float = Field(default=0.05, description="The kappa parameter for IBEA.")
+    """The kappa parameter for IBEA."""
+    binary_indicator: Literal["eps", "hv"] = Field(default="eps", description="The binary indicator for IBEA.")
+    """The binary indicator for IBEA."""
+
+
+SelectorOptions = RVEASelectorOptions | NSGA2SelectorOptions | NSGA3SelectorOptions | IBEASelectorOptions
+
+
+def selection_constructor(
+    problem: Problem, options: SelectorOptions, publisher: Publisher, verbosity: int, seed: int
+) -> BaseSelector:
+    """Construct a selection operator from given options.
+
+    Args:
+        problem (Problem): The optimization problem.
+        options (SelectorOptions): The options for the selection operator.
+        publisher (Publisher): The publisher to use for the operator.
+        verbosity (int): The verbosity level.
+        seed (int): The random seed.
+
+    Returns:
+        BaseSelector: The constructed selection operator.
+
+    Raises:
+        ValueError: If an unknown selection operator name is provided.
+    """
+    selection_types = {
+        "RVEASelector": RVEASelector,
+        "NSGA2Selector": NSGA2Selector,
+        "NSGA3Selector": NSGA3Selector,
+        "IBEASelector": IBEASelector,
+    }
+    options: dict = options.model_dump()
+    name = options.pop("name")
+    if name == "IBEASelector":
+        indi = options.pop("binary_indicator")
+        match indi:
+            case "eps":
+                options["binary_indicator"] = self_epsilon
+            case "hv":
+                options["binary_indicator"] = self_hv
+            case _:
+                raise ValueError(f"Unknown binary indicator: {indi}")
+    return selection_types[name](problem=problem, publisher=publisher, seed=seed, verbosity=verbosity, **options)