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
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
@staticmethod
def
default_mut_val_getter( vec: eckity.genetic_encodings.ga.vector_individual.Vector, idx: int) -> Union[int, float]:
@staticmethod
def
default_success_checker( old_vec: eckity.genetic_encodings.ga.vector_individual.Vector, new_vec: eckity.genetic_encodings.ga.vector_individual.Vector) -> bool:
def
default_cell_selector( self, vec: eckity.genetic_encodings.ga.vector_individual.Vector) -> List[int]:
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)