eckity.genetic_operators.mutations.vector_n_point_mutation

  1import random
  2
  3from eckity.genetic_operators.failable_operator import FailableOperator
  4from eckity.genetic_encodings.ga.vector_individual import Vector
  5
  6from typing import List, Tuple, Union
  7
  8
  9class VectorNPointMutation(FailableOperator):
 10    """
 11    Vector N Point Mutation.
 12
 13    Randomly chooses N vector cells and performs a small change in their values.
 14
 15    Parameters
 16    ----------
 17    n : int
 18        Number of mutation points.
 19
 20    probability : float
 21        The probability of the mutation operator to be applied
 22
 23    arity : int
 24        The number of individuals this mutation is applied on
 25
 26    cell_selector: callable
 27        Returns the indices of the cells to mutate
 28
 29    mut_val_getter: callable
 30        Returns a mutated value of a certain cell
 31
 32    success_checker: callable
 33        Checks if a given (mutated) cell value is legal
 34
 35    events: list of strings
 36        Events to publish before/after the mutation operator
 37    """
 38
 39    def __init__(
 40        self,
 41        n=1,
 42        probability=1.0,
 43        arity=1,
 44        cell_selector=None,
 45        mut_val_getter=None,
 46        success_checker=None,
 47        events=None,
 48        attempts=5,
 49    ):
 50        super().__init__(
 51            probability=probability,
 52            arity=arity,
 53            events=events,
 54            attempts=attempts,
 55        )
 56        self.n = n
 57
 58        if cell_selector is None:
 59            cell_selector = self.default_cell_selector
 60        self.cell_selector = cell_selector
 61
 62        if success_checker is None:
 63            success_checker = self.default_success_checker
 64        self.success_checker = success_checker
 65
 66        if mut_val_getter is None:
 67            mut_val_getter = self.default_mut_val_getter
 68        self.mut_val_getter = mut_val_getter
 69
 70    @staticmethod
 71    def default_mut_val_getter(vec: Vector, idx: int) -> Union[int, float]:
 72        return vec.get_random_number_in_bounds(vec, idx)
 73
 74    @staticmethod
 75    def default_success_checker(old_vec: Vector, new_vec: Vector) -> bool:
 76        return new_vec.check_if_in_bounds()
 77
 78    def default_cell_selector(self, vec: Vector) -> List[int]:
 79        vector_indices = range(vec.size())
 80        return random.sample(vector_indices, k=self.n)
 81
 82    def attempt_operator(
 83        self, individuals: List[Vector], attempt_num
 84    ) -> Tuple[bool, List[Vector]]:
 85        """
 86        Attempt to perform the mutation operator
 87
 88        Parameters
 89        ----------
 90        individuals : list of vectors
 91            vectors to mutate
 92
 93        attempt_num : int
 94            Current attempt number
 95
 96        Returns
 97        ----------
 98        Tuple[bool, List[Vector]]
 99            first return value determines if the the attempt succeeded
100            second return value is the operator result
101        """
102        succeeded = True
103        for individual in individuals:
104            # clone the individual to revert in case of failure
105            old_individual = individual.clone()
106
107            # randomly select n points of the vector (without repetitions)
108            m_points = self.cell_selector(individual)
109            # obtain the mutated values
110            mut_vals = [
111                self.mut_val_getter(individual, m_point)
112                for m_point in m_points
113            ]
114
115            # update the mutated value in-place
116            for m_point, mut_val in zip(m_points, mut_vals):
117                individual.set_cell_value(m_point, mut_val)
118
119            if not self.success_checker(old_individual, individual):
120                succeeded = False
121                individual.set_vector(old_individual.vector)
122                break
123
124        self.applied_individuals = individuals
125        return succeeded, individuals
126
127    def on_fail(self, payload):
128        """
129        The required fix when the operator fails, does nothing by default and can be overridden by subclasses
130
131        Parameters
132        ----------
133        payload : object
134            relevant data for on_fail (usually the individuals that the mutation was attempted to be applied on)
135        """
136        pass
class VectorNPointMutation(eckity.genetic_operators.failable_operator.FailableOperator):
 10class VectorNPointMutation(FailableOperator):
 11    """
 12    Vector N Point Mutation.
 13
 14    Randomly chooses N vector cells and performs a small change in their values.
 15
 16    Parameters
 17    ----------
 18    n : int
 19        Number of mutation points.
 20
 21    probability : float
 22        The probability of the mutation operator to be applied
 23
 24    arity : int
 25        The number of individuals this mutation is applied on
 26
 27    cell_selector: callable
 28        Returns the indices of the cells to mutate
 29
 30    mut_val_getter: callable
 31        Returns a mutated value of a certain cell
 32
 33    success_checker: callable
 34        Checks if a given (mutated) cell value is legal
 35
 36    events: list of strings
 37        Events to publish before/after the mutation operator
 38    """
 39
 40    def __init__(
 41        self,
 42        n=1,
 43        probability=1.0,
 44        arity=1,
 45        cell_selector=None,
 46        mut_val_getter=None,
 47        success_checker=None,
 48        events=None,
 49        attempts=5,
 50    ):
 51        super().__init__(
 52            probability=probability,
 53            arity=arity,
 54            events=events,
 55            attempts=attempts,
 56        )
 57        self.n = n
 58
 59        if cell_selector is None:
 60            cell_selector = self.default_cell_selector
 61        self.cell_selector = cell_selector
 62
 63        if success_checker is None:
 64            success_checker = self.default_success_checker
 65        self.success_checker = success_checker
 66
 67        if mut_val_getter is None:
 68            mut_val_getter = self.default_mut_val_getter
 69        self.mut_val_getter = mut_val_getter
 70
 71    @staticmethod
 72    def default_mut_val_getter(vec: Vector, idx: int) -> Union[int, float]:
 73        return vec.get_random_number_in_bounds(vec, idx)
 74
 75    @staticmethod
 76    def default_success_checker(old_vec: Vector, new_vec: Vector) -> bool:
 77        return new_vec.check_if_in_bounds()
 78
 79    def default_cell_selector(self, vec: Vector) -> List[int]:
 80        vector_indices = range(vec.size())
 81        return random.sample(vector_indices, k=self.n)
 82
 83    def attempt_operator(
 84        self, individuals: List[Vector], attempt_num
 85    ) -> Tuple[bool, List[Vector]]:
 86        """
 87        Attempt to perform the mutation operator
 88
 89        Parameters
 90        ----------
 91        individuals : list of vectors
 92            vectors to mutate
 93
 94        attempt_num : int
 95            Current attempt number
 96
 97        Returns
 98        ----------
 99        Tuple[bool, List[Vector]]
100            first return value determines if the the attempt succeeded
101            second return value is the operator result
102        """
103        succeeded = True
104        for individual in individuals:
105            # clone the individual to revert in case of failure
106            old_individual = individual.clone()
107
108            # randomly select n points of the vector (without repetitions)
109            m_points = self.cell_selector(individual)
110            # obtain the mutated values
111            mut_vals = [
112                self.mut_val_getter(individual, m_point)
113                for m_point in m_points
114            ]
115
116            # update the mutated value in-place
117            for m_point, mut_val in zip(m_points, mut_vals):
118                individual.set_cell_value(m_point, mut_val)
119
120            if not self.success_checker(old_individual, individual):
121                succeeded = False
122                individual.set_vector(old_individual.vector)
123                break
124
125        self.applied_individuals = individuals
126        return succeeded, individuals
127
128    def on_fail(self, payload):
129        """
130        The required fix when the operator fails, does nothing by default and can be overridden by subclasses
131
132        Parameters
133        ----------
134        payload : object
135            relevant data for on_fail (usually the individuals that the mutation was attempted to be applied on)
136        """
137        pass

Vector N Point Mutation.

Randomly chooses N vector cells and performs a small change in their values.

Parameters
  • n (int): Number of mutation points.
  • probability (float): The probability of the mutation operator to be applied
  • arity (int): The number of individuals this mutation is applied on
  • cell_selector (callable): Returns the indices of the cells to mutate
  • mut_val_getter (callable): Returns a mutated value of a certain cell
  • success_checker (callable): Checks if a given (mutated) cell value is legal
  • events (list of strings): Events to publish before/after the mutation operator
VectorNPointMutation( n=1, probability=1.0, arity=1, cell_selector=None, mut_val_getter=None, success_checker=None, events=None, attempts=5)
40    def __init__(
41        self,
42        n=1,
43        probability=1.0,
44        arity=1,
45        cell_selector=None,
46        mut_val_getter=None,
47        success_checker=None,
48        events=None,
49        attempts=5,
50    ):
51        super().__init__(
52            probability=probability,
53            arity=arity,
54            events=events,
55            attempts=attempts,
56        )
57        self.n = n
58
59        if cell_selector is None:
60            cell_selector = self.default_cell_selector
61        self.cell_selector = cell_selector
62
63        if success_checker is None:
64            success_checker = self.default_success_checker
65        self.success_checker = success_checker
66
67        if mut_val_getter is None:
68            mut_val_getter = self.default_mut_val_getter
69        self.mut_val_getter = mut_val_getter
n
cell_selector
success_checker
mut_val_getter
@staticmethod
def default_mut_val_getter( vec: eckity.genetic_encodings.ga.vector_individual.Vector, idx: int) -> Union[int, float]:
71    @staticmethod
72    def default_mut_val_getter(vec: Vector, idx: int) -> Union[int, float]:
73        return vec.get_random_number_in_bounds(vec, idx)
@staticmethod
def default_success_checker( old_vec: eckity.genetic_encodings.ga.vector_individual.Vector, new_vec: eckity.genetic_encodings.ga.vector_individual.Vector) -> bool:
75    @staticmethod
76    def default_success_checker(old_vec: Vector, new_vec: Vector) -> bool:
77        return new_vec.check_if_in_bounds()
def default_cell_selector( self, vec: eckity.genetic_encodings.ga.vector_individual.Vector) -> List[int]:
79    def default_cell_selector(self, vec: Vector) -> List[int]:
80        vector_indices = range(vec.size())
81        return random.sample(vector_indices, k=self.n)
def attempt_operator( self, individuals: List[eckity.genetic_encodings.ga.vector_individual.Vector], attempt_num) -> Tuple[bool, List[eckity.genetic_encodings.ga.vector_individual.Vector]]:
 83    def attempt_operator(
 84        self, individuals: List[Vector], attempt_num
 85    ) -> Tuple[bool, List[Vector]]:
 86        """
 87        Attempt to perform the mutation operator
 88
 89        Parameters
 90        ----------
 91        individuals : list of vectors
 92            vectors to mutate
 93
 94        attempt_num : int
 95            Current attempt number
 96
 97        Returns
 98        ----------
 99        Tuple[bool, List[Vector]]
100            first return value determines if the the attempt succeeded
101            second return value is the operator result
102        """
103        succeeded = True
104        for individual in individuals:
105            # clone the individual to revert in case of failure
106            old_individual = individual.clone()
107
108            # randomly select n points of the vector (without repetitions)
109            m_points = self.cell_selector(individual)
110            # obtain the mutated values
111            mut_vals = [
112                self.mut_val_getter(individual, m_point)
113                for m_point in m_points
114            ]
115
116            # update the mutated value in-place
117            for m_point, mut_val in zip(m_points, mut_vals):
118                individual.set_cell_value(m_point, mut_val)
119
120            if not self.success_checker(old_individual, individual):
121                succeeded = False
122                individual.set_vector(old_individual.vector)
123                break
124
125        self.applied_individuals = individuals
126        return succeeded, individuals

Attempt to perform the mutation operator

Parameters
  • individuals (list of vectors): vectors to mutate
  • attempt_num (int): Current attempt number
Returns
  • Tuple[bool, List[Vector]]: first return value determines if the the attempt succeeded second return value is the operator result
def on_fail(self, payload):
128    def on_fail(self, payload):
129        """
130        The required fix when the operator fails, does nothing by default and can be overridden by subclasses
131
132        Parameters
133        ----------
134        payload : object
135            relevant data for on_fail (usually the individuals that the mutation was attempted to be applied on)
136        """
137        pass

The required fix when the operator fails, does nothing by default and can be overridden by subclasses

Parameters
  • payload (object): relevant data for on_fail (usually the individuals that the mutation was attempted to be applied on)