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

desdeo/emo/operators/mutation.py

@@ -16,17 +16,18 @@ from desdeo.tools.message import (
     Message,
     MutationMessageTopics,
     PolarsDataFrameMessage,
+    TerminatorMessageTopics,
 )
-from desdeo.tools.patterns import Subscriber
+from desdeo.tools.patterns import Publisher, Subscriber
 
 
 class BaseMutation(Subscriber):
     """A base class for mutation operators."""
 
     @abstractmethod
-    def __init__(self, problem: Problem, **kwargs):
-        """Initialize a mu operator."""
-        super().__init__(**kwargs)
+    def __init__(self, problem: Problem, verbosity: int, publisher: Publisher):
+        """Initialize a mutation operator."""
+        super().__init__(verbosity=verbosity, publisher=publisher)
         self.problem = problem
         self.variable_symbols = [var.symbol for var in problem.get_flattened_variables()]
         self.lower_bounds = [var.lowerbound for var in problem.get_flattened_variables()]
@@ -83,21 +84,23 @@ class BoundedPolynomialMutation(BaseMutation):
         *,
         problem: Problem,
         seed: int,
+        verbosity: int,
+        publisher: Publisher,
         mutation_probability: float | None = None,
         distribution_index: float = 20,
-        **kwargs,
     ):
         """Initialize a bounded polynomial mutation operator.
 
         Args:
             problem (Problem): The problem object.
             seed (int): The seed for the random number generator.
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
             mutation_probability (float | None, optional): The probability of mutation. Defaults to None.
-            distribution_index (float, optional): The distributaion index for polynomial mutation. Defaults to 20.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
+            distribution_index (float, optional): The distribution index for polynomial mutation. Defaults to 20.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         if self.variable_combination != VariableDomainTypeEnum.continuous:
             raise ValueError("This mutation operator only works with continuous variables.")
         if mutation_probability is None:
@@ -125,7 +128,7 @@ class BoundedPolynomialMutation(BaseMutation):
         # TODO(@light-weaver): Extract to a numba jitted function
         self.offspring_original = offsprings
         self.parents = parents  # Not used, but kept for consistency
-        offspring = offsprings.to_numpy()
+        offspring = offsprings.to_numpy(writable=True)
         min_val = np.ones_like(offspring) * self.lower_bounds
         max_val = np.ones_like(offspring) * self.upper_bounds
         k = self.rng.random(size=offspring.shape)
@@ -242,8 +245,9 @@ class BinaryFlipMutation(BaseMutation):
         *,
         problem: Problem,
         seed: int,
+        verbosity: int,
+        publisher: Publisher,
         mutation_probability: float | None = None,
-        **kwargs,
     ):
         """Initialize a binary flip mutation operator.
 
@@ -253,10 +257,11 @@ class BinaryFlipMutation(BaseMutation):
             mutation_probability (float | None, optional): The probability of mutation. If None,
                 the probability will be set to be 1/n, where n is the number of decision variables
                 in the problem. Defaults to None.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
 
         if self.variable_combination != VariableDomainTypeEnum.binary:
             raise ValueError("This mutation operator only works with binary variables.")
@@ -284,7 +289,7 @@ class BinaryFlipMutation(BaseMutation):
         """
         self.offspring_original = copy.copy(offsprings)
         self.parents = parents  # Not used, but kept for consistency
-        offspring = offsprings.to_numpy().astype(dtype=np.bool)
+        offspring = offsprings.to_numpy(writable=True).astype(dtype=np.bool)
 
         # create a boolean mask based on the mutation probability
         flip_mask = self.rng.random(offspring.shape) < self.mutation_probability
@@ -373,8 +378,9 @@ class IntegerRandomMutation(BaseMutation):
         *,
         problem: Problem,
         seed: int,
+        verbosity: int,
+        publisher: Publisher,
         mutation_probability: float | None = None,
-        **kwargs,
     ):
         """Initialize a random integer mutation operator.
 
@@ -384,10 +390,11 @@ class IntegerRandomMutation(BaseMutation):
             mutation_probability (float | None, optional): The probability of mutation. If None,
                 the probability will be set to be 1/n, where n is the number of decision variables
                 in the problem. Defaults to None.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
 
         if self.variable_combination != VariableDomainTypeEnum.integer:
             raise ValueError("This mutation operator only works with integer variables.")
@@ -416,7 +423,7 @@ class IntegerRandomMutation(BaseMutation):
         self.offspring_original = copy.copy(offsprings)
         self.parents = parents  # Not used, but kept for consistency
 
-        population = offsprings.to_numpy().astype(int)
+        population = offsprings.to_numpy(writable=True).astype(int)
 
         # create a boolean mask based on the mutation probability
         mutation_mask = self.rng.random(population.shape) < self.mutation_probability
@@ -507,8 +514,9 @@ class MixedIntegerRandomMutation(BaseMutation):
         *,
         problem: Problem,
         seed: int,
+        verbosity: int,
+        publisher: Publisher,
         mutation_probability: float | None = None,
-        **kwargs,
     ):
         """Initialize a random mixed_integer mutation operator.
 
@@ -518,10 +526,11 @@ class MixedIntegerRandomMutation(BaseMutation):
             mutation_probability (float | None, optional): The probability of mutation. If None,
                 the probability will be set to be 1/n, where n is the number of decision variables
                 in the problem. Defaults to None.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
 
         if mutation_probability is None:
             self.mutation_probability = 1 / len(self.variable_symbols)
@@ -548,7 +557,7 @@ class MixedIntegerRandomMutation(BaseMutation):
         self.offspring_original = copy.copy(offsprings)
         self.parents = parents  # Not used, but kept for consistency
 
-        population = offsprings.to_numpy().astype(float)
+        population = offsprings.to_numpy(writable=True).astype(float)
 
         # create a boolean mask based on the mutation probability
         mutation_mask = self.rng.random(population.shape) < self.mutation_probability
@@ -649,9 +658,10 @@ class MPTMutation(BaseMutation):
         *,
         problem: Problem,
         seed: int,
+        verbosity: int,
+        publisher: Publisher,
         mutation_probability: float | None = None,
         mutation_exponent: float = 2.0,
-        **kwargs,
     ):
         """Initialize a small mutation operator.
 
@@ -660,10 +670,12 @@ class MPTMutation(BaseMutation):
             seed (int): RNG seed.
             mutation_probability (float | None): Probability of mutation per gene.
             mutation_exponent (float): Controls strength of small mutation (larger means smaller mutations).
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
                 publisher must be passed. See the Subscriber class for more information.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.rng = np.random.default_rng(seed)
         self.seed = seed
         self.mutation_exponent = mutation_exponent
@@ -699,7 +711,7 @@ class MPTMutation(BaseMutation):
         self.offspring_original = copy.copy(offsprings)
         self.parents = parents
 
-        population = offsprings.to_numpy().astype(float)
+        population = offsprings.to_numpy(writable=True).astype(float)
 
         for i in range(population.shape[0]):
             for j, var in enumerate(self.problem.variables):
@@ -757,6 +769,9 @@ class MPTMutation(BaseMutation):
         ]
 
 
+#TODO (@light-weaver): Get rid of the max_generations parameter and instead get it from a message
+# Additionally, allow the operator to use max_evaluations as a basis for decay
+# Make sure that the ratio never exceeds 1.0, otherwise there will be issues
 class NonUniformMutation(BaseMutation):
     """Non-uniform mutation operator.
 
@@ -779,17 +794,18 @@ class NonUniformMutation(BaseMutation):
     @property
     def interested_topics(self):
         """The message topics that the mutation operator is interested in."""
-        return []
+        return [TerminatorMessageTopics.GENERATION]
 
     def __init__(
         self,
         *,
         problem: Problem,
         seed: int,
+        max_generations: int,
+        verbosity: int,
+        publisher: Publisher,
         mutation_probability: float | None = None,
         b: float = 5.0,  # decay parameter
-        max_generations: int,
-        **kwargs,
     ):
         """Initialize a Non-uniform mutation operator.
 
@@ -801,9 +817,11 @@ class NonUniformMutation(BaseMutation):
             b (float): Non-uniform mutation decay parameter. Higher values cause
                 faster reduction in mutation strength over generations.
             max_generations (int): Maximum number of generations in the evolutionary run. Used to scale mutation decay.
-            **kwargs: Additional keyword arguments passed to the base mutation class.
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.rng = np.random.default_rng(seed)
         self.seed = seed
         self.b = b
@@ -858,7 +876,7 @@ class NonUniformMutation(BaseMutation):
         self.offspring_original = copy.copy(offsprings)
         self.parents = parents
 
-        population = offsprings.to_numpy().astype(float)
+        population = offsprings.to_numpy(writable=True).astype(float)
 
         for i in range(population.shape[0]):
             for j, var in enumerate(self.problem.variables):
@@ -875,9 +893,17 @@ class NonUniformMutation(BaseMutation):
 
         return self.offspring
 
-    def update(self, generation: int, **kwargs):
+    def update(self, message: Message):
         """Update current generation (used to reduce mutation strength over time)."""
-        self.current_generation = generation
+        if not isinstance(message.topic, TerminatorMessageTopics):
+            return
+        if not isinstance(message.value, int):
+            return
+        if message.topic != TerminatorMessageTopics.GENERATION:
+            raise ValueError(
+                f"Expected message topic {TerminatorMessageTopics.GENERATION}, got {message.topic}."
+            )
+        self.current_generation = message.value
 
     def state(self) -> Sequence[Message]:
         """Return state messages."""
@@ -923,8 +949,9 @@ class SelfAdaptiveGaussianMutation(BaseMutation):
         *,
         problem: Problem,
         seed: int,
+        verbosity: int,
+        publisher: Publisher,
         mutation_probability: float | None = None,
-        **kwargs,
     ):
         """Initialize the self-adaptive Gaussian mutation operator.
 
@@ -933,7 +960,9 @@ class SelfAdaptiveGaussianMutation(BaseMutation):
             seed (int): Seed for the random number generator to ensure reproducibility.
             mutation_probability (float | None): Probability of mutating each gene.
                 If None, it defaults to 1 divided by the number of variables.
-            **kwargs: Additional keyword arguments passed to the base mutation class.
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
 
         Attributes:
             rng (Generator): NumPy random number generator initialized with the given seed.
@@ -943,7 +972,7 @@ class SelfAdaptiveGaussianMutation(BaseMutation):
             tau_prime (float): Global learning rate, used in step size adaptation.
             tau (float): Local learning rate, used in step size adaptation.
         """
-        super().__init__(problem=problem, **kwargs)
+        super().__init__(problem=problem, verbosity=verbosity, publisher=publisher)
 
         self.rng = np.random.default_rng(seed)
         self.seed = seed
@@ -975,7 +1004,7 @@ class SelfAdaptiveGaussianMutation(BaseMutation):
         self.offspring_original = offsprings
         self.parents = parents
 
-        offspring_array = offsprings.to_numpy().astype(float)
+        offspring_array = offsprings.to_numpy(writable=True).astype(float)
 
         if step_sizes is None:
             step_sizes = np.full_like(offspring_array, fill_value=0.1)
@@ -1051,3 +1080,145 @@ class SelfAdaptiveGaussianMutation(BaseMutation):
                 value=self.mutation_probability,
             ),
         ]
+
+
+class PowerMutation(BaseMutation):
+    """Implements the Power Mutation (PM) operator for real and integer variables."""
+
+    @property
+    def provided_topics(self) -> dict[int, Sequence[MutationMessageTopics]]:
+        """The message topics provided by the mutation operator."""
+        return {
+            0: [],
+            1: [MutationMessageTopics.MUTATION_PROBABILITY],
+            2: [
+                MutationMessageTopics.MUTATION_PROBABILITY,
+                MutationMessageTopics.OFFSPRING_ORIGINAL,
+                MutationMessageTopics.OFFSPRINGS,
+            ],
+        }
+
+    @property
+    def interested_topics(self):
+        """The message topics that the mutation operator listens to (none in this case)."""
+        return []
+
+    def __init__(
+        self,
+        *,
+        problem: Problem,
+        seed: int,
+        verbosity: int,
+        publisher: Publisher,
+        p: float = 1.5,
+        mutation_probability: float | None = None,
+    ):
+        """Initialize the PowerMutation operator.
+
+        Args:
+            problem (Problem): The problem definition containing variable bounds and types.
+            seed (int): Random seed for reproducibility.
+            p (float): Power distribution parameter. Controls the perturbation magnitude. Default is 1.5.
+            mutation_probability (float | None): Per-variable mutation probability. Defaults to 1/n.
+            verbosity (int): The verbosity level of the operator. See the `provided_topics` attribute to see what
+                messages are provided at each verbosity level. Recommended value is 1.
+            publisher (Publisher): The publisher to which the operator will send messages.
+        """
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
+        self.p = p
+        self.mutation_probability = (
+            mutation_probability if mutation_probability is not None else 1 / len(self.variable_symbols)
+        )
+        self.rng = np.random.default_rng(seed)
+        self.seed = seed
+        self.offspring_original: pl.DataFrame
+        self.parents: pl.DataFrame
+        self.offspring: pl.DataFrame
+
+    def do(self, offsprings: pl.DataFrame, parents: pl.DataFrame) -> pl.DataFrame:
+        """Apply Power Mutation to the given offspring population.
+
+        Args:
+            offsprings (pl.DataFrame): The offspring population to mutate.
+            parents (pl.DataFrame): The parent population
+
+        Returns:
+            pl.DataFrame: Mutated offspring population.
+        """
+        self.offspring_original = copy.copy(offsprings)
+        self.parents = parents
+
+        if self.mutation_probability == 0.0:
+            self.offspring = offsprings.clone()
+            self.notify()
+            return self.offspring
+
+        population = offsprings.to_numpy(writable=True).astype(float)
+        mutation_mask = self.rng.random(population.shape) < self.mutation_probability
+        mutated = population.copy()
+
+        for i, var in enumerate(self.problem.variables):
+            lower_bound, upper_bound = var.lowerbound, var.upperbound
+            x_i = population[:, i]
+
+            u_i = self.rng.random(len(x_i))  # uniform random number
+            s_i = u_i ** (1 / self.p)  # random number that follows the power distribution
+
+            r_i = self.rng.random(len(x_i))  # another uniform random number
+            direction = ((x_i - lower_bound) / (upper_bound - lower_bound)) < r_i  # used as condition
+
+            xi_mutated = np.where(direction, x_i - s_i * (x_i - lower_bound), x_i + s_i * (upper_bound - x_i))
+
+            # Apply mutation based on mask
+            mutated[:, i] = np.where(mutation_mask[:, i], xi_mutated, x_i)
+
+        # Convert back to DataFrame
+        self.offspring = pl.from_numpy(mutated, schema=self.variable_symbols).select(pl.all()).cast(pl.Float64)
+        self.notify()
+
+        return self.offspring
+
+    def update(self, *_, **__):
+        """No update logic needed."""
+
+    def state(self) -> Sequence[Message]:
+        """Return mutation-related state messages based on verbosity level.
+
+        Returns:
+            List of messages reporting mutation probability, input, and output (at higher verbosity).
+        """
+        if self.offspring_original is None or self.offspring is None or self.verbosity == 0:
+            return []
+
+        if self.verbosity == 1:
+            return [
+                FloatMessage(
+                    topic=MutationMessageTopics.MUTATION_PROBABILITY,
+                    source=self.__class__.__name__,
+                    value=self.mutation_probability,
+                ),
+            ]
+
+        # Verbosity == 2
+        return [
+            PolarsDataFrameMessage(
+                topic=MutationMessageTopics.OFFSPRING_ORIGINAL,
+                source=self.__class__.__name__,
+                value=self.offspring_original,
+            ),
+            PolarsDataFrameMessage(
+                topic=MutationMessageTopics.PARENTS,
+                source=self.__class__.__name__,
+                value=self.parents,
+            ),
+            PolarsDataFrameMessage(
+                topic=MutationMessageTopics.OFFSPRINGS,
+                source=self.__class__.__name__,
+                value=self.offspring,
+            ),
+            FloatMessage(
+                topic=MutationMessageTopics.MUTATION_PROBABILITY,
+                source=self.__class__.__name__,
+                value=self.mutation_probability,
+            ),
+        ]

desdeo/emo/operators/scalar_selection.py

@@ -0,0 +1,202 @@
+"""Classs for scalar selection operators."""
+
+from abc import abstractmethod
+from collections.abc import Sequence
+
+import numpy as np
+import polars as pl
+
+from desdeo.emo.operators.selection import SolutionType
+from desdeo.tools.message import Message, SelectorMessageTopics
+from desdeo.tools.patterns import Publisher, Subscriber
+
+
+class BaseScalarSelector(Subscriber):
+    """A base class for selection operators."""
+
+    @property
+    def provided_topics(self):
+        return {
+            0: [],
+            1: [],
+            2: [],
+        }
+
+    @property
+    def interested_topics(self):
+        return [
+            SelectorMessageTopics.SELECTED_FITNESS,
+        ]
+
+    def __init__(self, verbosity: int, publisher: Publisher):
+        """Initialize a selection operator."""
+        super().__init__(verbosity=verbosity, publisher=publisher)
+        self.fitness: np.ndarray | None = None
+
+    @abstractmethod
+    def _do(
+        self,
+        solutions: tuple[SolutionType, pl.DataFrame],
+        fitness: np.ndarray | None = None,
+    ) -> tuple[SolutionType, pl.DataFrame]:
+        """Perform the selection operation.
+
+        Args:
+            solutions (tuple[SolutionType, pl.DataFrame]): the decision variables as the first element.
+                The second element is the objective values, targets, and constraint violations.
+            fitness (np.ndarray | None, optional): The fitness values of the solutions. If None, the fitness is
+                calculated from the messages sent by the publisher.
+
+        Returns:
+            SolutionType: The selected decision variables.
+        """
+
+    def do(
+        self,
+        solutions: tuple[SolutionType, pl.DataFrame],
+        fitness: np.ndarray | None = None,
+    ) -> tuple[SolutionType, pl.DataFrame]:
+        """Perform the selection operation.
+
+        Args:
+            solutions (tuple[SolutionType, pl.DataFrame]): the decision variables as the first element.
+                The second element is the objective values, targets, and constraint violations.
+            fitness (np.ndarray | None, optional): The fitness values of the solutions. If None, the fitness is
+                calculated from the messages sent by the publisher.
+
+        Returns:
+            SolutionType: The selected decision variables.
+        """
+        if fitness is not None and self.fitness is not None:
+            raise RuntimeError("The fitness is being set twice.")
+        if fitness is None and self.fitness is None:
+            raise RuntimeError(
+                "The fitness is not set. Either pass it as an argument or make sure the publisher sends it."
+            )
+        if fitness is None:
+            fitness = self.fitness
+        if len(fitness) != len(solutions[0]):
+            raise ValueError(
+                f"The length of the fitness array ({len(fitness)}) does not match"
+                f" the number of solutions ({len(solutions[0])})."
+            )
+        returnval = self._do(solutions, fitness)
+        self.fitness = None  # Reset fitness after selection
+        return returnval
+
+    def update(self, message: Message) -> None:
+        """Update the operator with a message.
+
+        Args:
+            message (Message): The message to update the operator with.
+        """
+        if message.topic == SelectorMessageTopics.SELECTED_FITNESS and isinstance(message.value, np.ndarray):
+            self.fitness = message.value
+        else:
+            raise ValueError(f"Unknown message topic: {message.topic}")
+
+    def state(self) -> Sequence[Message]:
+        return []
+
+
+class TournamentSelection(BaseScalarSelector):
+    """A tournament selection operator."""
+
+    def __init__(
+        self,
+        *,
+        winner_size: int,
+        verbosity: int,
+        publisher: Publisher,
+        tournament_size: int = 2,
+        seed: int | None = None,
+        selection_probability: float | None = None,
+    ) -> None:
+        """Initialize the tournament selection operator.
+
+        Args:
+            winner_size (int): The number of winners to select.
+            verbosity (int): The verbosity level of the operator.
+            publisher (Publisher): The publisher to send messages to.
+            tournament_size (int, optional): The size of the tournament. Defaults to 2, which corresponds to binary
+                tournament.
+            seed (int | None, optional): The seed for the random number generator. If None, the deterministic tournament
+                selection is used, i.e., the solution with the highest fitness in the tournament is always selected.
+                Otherwise the selection is stochastic, and the solution is selected with a probability proportional to
+                its fitness. Defaults to None.
+            selection_probability (float | None, optional): The probability of selecting a solution in the tournament.
+                If None, but a seed is provided, then the probabilities are proportional to the fitness values of the
+                solutions in the tournament. If None and no seed is provided, then the selection is deterministic.
+                If a value is provided, and the seed is not None, then the selection is stochastic, and the
+                probabilities of choosing the k-best solution in the tournament is given by p * (1 - p) ** (k - 1),
+                where p is the selection probability. Note that doing selection with a probability proportional to
+                fitness is equivalent to roulette wheel selection.
+        """
+        super().__init__(verbosity=verbosity, publisher=publisher)
+        self.winner_size = winner_size
+        self.tournament_size = tournament_size
+        self.seed = seed
+        self.rng = np.random.default_rng(seed)
+        self.selection_probability = selection_probability
+        if self.seed is None and self.selection_probability is not None:
+            raise ValueError(
+                "If selection_probability is provided, seed must also be provided to ensure stochastic selection."
+            )
+
+    @staticmethod
+    def deterministic_select(indices: np.ndarray, fitness: np.ndarray) -> int:
+        """Select the index of the solution with the highest fitness from the given indices.
+
+        Args:
+            indices (np.ndarray): The indices of the solutions to select from.
+            fitness (np.ndarray): The fitness values of the solutions.
+
+        Returns:
+            int: The index of the solution with the highest fitness.
+        """
+        return indices[np.argmax(fitness)]
+
+    def stochastic_select(self, indices: np.ndarray, fitness: np.ndarray) -> int:
+        """Select the index of the solution with a probability proportional to its fitness from the given indices.
+
+        Args:
+            indices (np.ndarray): The indices of the solutions to select from.
+            fitness (np.ndarray): The fitness values of the solutions.
+
+        Returns:
+            int: The index of the selected solution.
+        """
+        if self.selection_probability is None:
+            probabilities = fitness / np.sum(fitness)
+            probabilities = np.cumsum(probabilities)
+        else:
+            indices = indices[np.argsort(fitness)[::-1]]  # Sort indices by fitness in descending order
+            probabilities = np.array(
+                [self.selection_probability * (1 - self.selection_probability) ** i for i in range(len(indices))]
+            )
+        random_value = self.rng.random()
+        selected_index = np.searchsorted(probabilities, random_value)
+        return indices[selected_index]
+
+    def _do(
+        self, solutions: tuple[SolutionType, pl.DataFrame], fitness: np.ndarray | None = None
+    ) -> tuple[SolutionType, pl.DataFrame]:
+        """Perform the tournament selection operation.
+
+        Args:
+            solutions (tuple[SolutionType, pl.DataFrame]): The decision variables and their outputs.
+            fitness (np.ndarray | None, optional): The fitness values of the solutions.
+
+        Returns:
+            tuple[SolutionType, pl.DataFrame]: The selected decision variables and their outputs.
+        """
+        selected_indices = np.zeros(self.winner_size, dtype=int)
+        for i in range(self.winner_size):
+            tournament_indices = self.rng.choice(range(len(solutions[0])), size=self.tournament_size, replace=True)
+            if self.seed is None:
+                selected_indices[i] = self.deterministic_select(tournament_indices, fitness[tournament_indices])
+            else:
+                selected_indices[i] = self.stochastic_select(tournament_indices, fitness[tournament_indices])
+        selected_solutions = solutions[0][selected_indices]
+        selected_outputs = solutions[1][selected_indices]
+        return selected_solutions, selected_outputs