eckity.subpopulation
1import logging 2import random 3from typing import List 4 5import numpy as np 6 7from eckity.creators.creator import Creator 8from eckity.genetic_operators import SelectionMethod, TournamentSelection 9 10logger = logging.getLogger(__name__) 11 12 13class Subpopulation: 14 """ 15 Subgroup of the experiment population. 16 17 Contains a specific encoding, fitness evaluation method, creator list, 18 operator sequence and selection methods. 19 20 Parameters 21 ---------- 22 evaluator: IndividualEvaluator 23 fitness evaluation method for the individuals of this sub-population 24 25 creators: Creator or list of Creators, default=None 26 possible creators to generate individuals according to the encoding 27 of this sub-population (GPTrees, Bit Vectors etc.) 28 29 pcr: list of integers, default=None 30 probability mapping for each creator in creators parameter. 31 Length must match the length of creators parameter. 32 33 operators_sequence: list of Crossovers and Mutations, default=None 34 Crossovers and mutations that changes the individuals' representations. 35 The operators are done by their order in the list in each generation. 36 See eckity.genetic_operators for more information. 37 38 selection_methods: list of SelectionMethods 39 Methods for selecting individuals in each generation. 40 See eckity.genetic_operators for more details on selection methods 41 42 elitism_rate: float, default=0.0 43 What percentage of the sub-population individuals 44 should be kept as-is for the next generation 45 46 population_size: int, default=200 47 The number of individuals in this sub-population. 48 49 individuals: list of Individuals, default=None 50 The individuals list of this sub-population. 51 52 higher_is_better: bool, default=False 53 Determines if the fitness values of this sub-population's 54 individuals should be maximized or minimized. 55 56 Attributes 57 ---------- 58 n_elite: int 59 Number of the sub-population's elite individuals. 60 In every generation, there will be n_elites slots 61 for the elite individuals that will be copied as 62 they are to the next generation. 63 """ 64 65 def __init__( 66 self, 67 evaluator, 68 creators=None, 69 pcr=None, 70 operators_sequence=None, 71 selection_methods: List[SelectionMethod] = None, 72 elitism_rate=0.0, 73 population_size=200, 74 individuals=None, 75 higher_is_better=False, 76 ): 77 78 # verify valid creators and creation probability inputs 79 if creators is None: 80 raise ValueError("Must specify at least one creator") 81 elif isinstance(creators, Creator): 82 creators = [creators] 83 elif isinstance(creators, list): 84 if len(creators) == 0: 85 raise ValueError("Creators cannot be empty list") 86 for creator in creators: 87 if not isinstance(creator, Creator): 88 raise ValueError( 89 "Detected non-creator instance in creators list" 90 ) 91 else: 92 raise ValueError( 93 "Creators must be either a Creator or a list of Creators. " 94 f"Got unexpected type of {type(creators)}", 95 ) 96 97 if pcr is None: 98 pcr = [1 / len(creators) for _ in creators] 99 100 if len(creators) != len(pcr): 101 raise ValueError( 102 f"Number of creators ({len(creators)}) \ 103 must match number of creation probabilities {(len(pcr))}!" 104 ) 105 if sum(pcr) != 1: 106 raise ValueError( 107 f"Sum of creation probabilities ({pcr}) must be 1!" 108 ) 109 110 # set default args 111 if operators_sequence is None: 112 raise ValueError("Must specify at least one operator") 113 114 if selection_methods is None: 115 selection_methods = [ 116 TournamentSelection( 117 tournament_size=10 118 ) 119 ] 120 121 self.creators = creators 122 self._pcr = pcr 123 self._operators_sequence = operators_sequence 124 self.population_size = population_size 125 self._selection_methods = selection_methods 126 self.higher_is_better = higher_is_better 127 self.evaluator = evaluator 128 129 self.n_elite = round(elitism_rate * self.population_size) 130 131 if self.n_elite == 0 and elitism_rate > 0.0: 132 logger.warning( 133 "Detected elitism_rate > 0 but 0 elites. " 134 "Try increasing elitism_rate." 135 ) 136 137 self.individuals = individuals 138 139 def create_subpopulation_individuals(self): 140 if self.individuals is None: 141 # Select one creator to generate individuals, 142 # with respect to the creators' probabilities 143 144 # choices returns [selected_creator] 145 selected_creator = random.choices( 146 self.creators, weights=self._pcr 147 )[0] 148 self.individuals = selected_creator.create_individuals( 149 self.population_size, self.higher_is_better 150 ) 151 152 def get_operators_sequence(self): 153 return self._operators_sequence 154 155 def get_selection_methods(self): 156 return self._selection_methods 157 158 def get_best_individual(self): 159 sorted_inds = sorted( 160 self.individuals, 161 key=lambda ind: ind.get_augmented_fitness(), 162 reverse=self.higher_is_better, 163 ) 164 return sorted_inds[0] 165 166 def get_worst_individual(self): 167 sorted_inds = sorted( 168 self.individuals, 169 key=lambda ind: ind.get_augmented_fitness(), 170 reverse=not self.higher_is_better, 171 ) 172 return sorted_inds[0] 173 174 def get_average_fitness(self): 175 return np.mean( 176 [indiv.get_pure_fitness() for indiv in self.individuals] 177 ) 178 179 def contains_individual(self, individual): 180 return individual in self.individuals
logger =
<Logger eckity.subpopulation (INFO)>
class
Subpopulation:
14class Subpopulation: 15 """ 16 Subgroup of the experiment population. 17 18 Contains a specific encoding, fitness evaluation method, creator list, 19 operator sequence and selection methods. 20 21 Parameters 22 ---------- 23 evaluator: IndividualEvaluator 24 fitness evaluation method for the individuals of this sub-population 25 26 creators: Creator or list of Creators, default=None 27 possible creators to generate individuals according to the encoding 28 of this sub-population (GPTrees, Bit Vectors etc.) 29 30 pcr: list of integers, default=None 31 probability mapping for each creator in creators parameter. 32 Length must match the length of creators parameter. 33 34 operators_sequence: list of Crossovers and Mutations, default=None 35 Crossovers and mutations that changes the individuals' representations. 36 The operators are done by their order in the list in each generation. 37 See eckity.genetic_operators for more information. 38 39 selection_methods: list of SelectionMethods 40 Methods for selecting individuals in each generation. 41 See eckity.genetic_operators for more details on selection methods 42 43 elitism_rate: float, default=0.0 44 What percentage of the sub-population individuals 45 should be kept as-is for the next generation 46 47 population_size: int, default=200 48 The number of individuals in this sub-population. 49 50 individuals: list of Individuals, default=None 51 The individuals list of this sub-population. 52 53 higher_is_better: bool, default=False 54 Determines if the fitness values of this sub-population's 55 individuals should be maximized or minimized. 56 57 Attributes 58 ---------- 59 n_elite: int 60 Number of the sub-population's elite individuals. 61 In every generation, there will be n_elites slots 62 for the elite individuals that will be copied as 63 they are to the next generation. 64 """ 65 66 def __init__( 67 self, 68 evaluator, 69 creators=None, 70 pcr=None, 71 operators_sequence=None, 72 selection_methods: List[SelectionMethod] = None, 73 elitism_rate=0.0, 74 population_size=200, 75 individuals=None, 76 higher_is_better=False, 77 ): 78 79 # verify valid creators and creation probability inputs 80 if creators is None: 81 raise ValueError("Must specify at least one creator") 82 elif isinstance(creators, Creator): 83 creators = [creators] 84 elif isinstance(creators, list): 85 if len(creators) == 0: 86 raise ValueError("Creators cannot be empty list") 87 for creator in creators: 88 if not isinstance(creator, Creator): 89 raise ValueError( 90 "Detected non-creator instance in creators list" 91 ) 92 else: 93 raise ValueError( 94 "Creators must be either a Creator or a list of Creators. " 95 f"Got unexpected type of {type(creators)}", 96 ) 97 98 if pcr is None: 99 pcr = [1 / len(creators) for _ in creators] 100 101 if len(creators) != len(pcr): 102 raise ValueError( 103 f"Number of creators ({len(creators)}) \ 104 must match number of creation probabilities {(len(pcr))}!" 105 ) 106 if sum(pcr) != 1: 107 raise ValueError( 108 f"Sum of creation probabilities ({pcr}) must be 1!" 109 ) 110 111 # set default args 112 if operators_sequence is None: 113 raise ValueError("Must specify at least one operator") 114 115 if selection_methods is None: 116 selection_methods = [ 117 TournamentSelection( 118 tournament_size=10 119 ) 120 ] 121 122 self.creators = creators 123 self._pcr = pcr 124 self._operators_sequence = operators_sequence 125 self.population_size = population_size 126 self._selection_methods = selection_methods 127 self.higher_is_better = higher_is_better 128 self.evaluator = evaluator 129 130 self.n_elite = round(elitism_rate * self.population_size) 131 132 if self.n_elite == 0 and elitism_rate > 0.0: 133 logger.warning( 134 "Detected elitism_rate > 0 but 0 elites. " 135 "Try increasing elitism_rate." 136 ) 137 138 self.individuals = individuals 139 140 def create_subpopulation_individuals(self): 141 if self.individuals is None: 142 # Select one creator to generate individuals, 143 # with respect to the creators' probabilities 144 145 # choices returns [selected_creator] 146 selected_creator = random.choices( 147 self.creators, weights=self._pcr 148 )[0] 149 self.individuals = selected_creator.create_individuals( 150 self.population_size, self.higher_is_better 151 ) 152 153 def get_operators_sequence(self): 154 return self._operators_sequence 155 156 def get_selection_methods(self): 157 return self._selection_methods 158 159 def get_best_individual(self): 160 sorted_inds = sorted( 161 self.individuals, 162 key=lambda ind: ind.get_augmented_fitness(), 163 reverse=self.higher_is_better, 164 ) 165 return sorted_inds[0] 166 167 def get_worst_individual(self): 168 sorted_inds = sorted( 169 self.individuals, 170 key=lambda ind: ind.get_augmented_fitness(), 171 reverse=not self.higher_is_better, 172 ) 173 return sorted_inds[0] 174 175 def get_average_fitness(self): 176 return np.mean( 177 [indiv.get_pure_fitness() for indiv in self.individuals] 178 ) 179 180 def contains_individual(self, individual): 181 return individual in self.individuals
Subgroup of the experiment population.
Contains a specific encoding, fitness evaluation method, creator list, operator sequence and selection methods.
Parameters
- evaluator (IndividualEvaluator): fitness evaluation method for the individuals of this sub-population
- creators (Creator or list of Creators, default=None): possible creators to generate individuals according to the encoding of this sub-population (GPTrees, Bit Vectors etc.)
- pcr (list of integers, default=None): probability mapping for each creator in creators parameter. Length must match the length of creators parameter.
- operators_sequence (list of Crossovers and Mutations, default=None): Crossovers and mutations that changes the individuals' representations. The operators are done by their order in the list in each generation. See eckity.genetic_operators for more information.
- selection_methods (list of SelectionMethods): Methods for selecting individuals in each generation. See eckity.genetic_operators for more details on selection methods
- elitism_rate (float, default=0.0): What percentage of the sub-population individuals should be kept as-is for the next generation
- population_size (int, default=200): The number of individuals in this sub-population.
- individuals (list of Individuals, default=None): The individuals list of this sub-population.
- higher_is_better (bool, default=False): Determines if the fitness values of this sub-population's individuals should be maximized or minimized.
Attributes
- n_elite (int): Number of the sub-population's elite individuals. In every generation, there will be n_elites slots for the elite individuals that will be copied as they are to the next generation.
Subpopulation( evaluator, creators=None, pcr=None, operators_sequence=None, selection_methods: List[eckity.genetic_operators.selections.selection_method.SelectionMethod] = None, elitism_rate=0.0, population_size=200, individuals=None, higher_is_better=False)
66 def __init__( 67 self, 68 evaluator, 69 creators=None, 70 pcr=None, 71 operators_sequence=None, 72 selection_methods: List[SelectionMethod] = None, 73 elitism_rate=0.0, 74 population_size=200, 75 individuals=None, 76 higher_is_better=False, 77 ): 78 79 # verify valid creators and creation probability inputs 80 if creators is None: 81 raise ValueError("Must specify at least one creator") 82 elif isinstance(creators, Creator): 83 creators = [creators] 84 elif isinstance(creators, list): 85 if len(creators) == 0: 86 raise ValueError("Creators cannot be empty list") 87 for creator in creators: 88 if not isinstance(creator, Creator): 89 raise ValueError( 90 "Detected non-creator instance in creators list" 91 ) 92 else: 93 raise ValueError( 94 "Creators must be either a Creator or a list of Creators. " 95 f"Got unexpected type of {type(creators)}", 96 ) 97 98 if pcr is None: 99 pcr = [1 / len(creators) for _ in creators] 100 101 if len(creators) != len(pcr): 102 raise ValueError( 103 f"Number of creators ({len(creators)}) \ 104 must match number of creation probabilities {(len(pcr))}!" 105 ) 106 if sum(pcr) != 1: 107 raise ValueError( 108 f"Sum of creation probabilities ({pcr}) must be 1!" 109 ) 110 111 # set default args 112 if operators_sequence is None: 113 raise ValueError("Must specify at least one operator") 114 115 if selection_methods is None: 116 selection_methods = [ 117 TournamentSelection( 118 tournament_size=10 119 ) 120 ] 121 122 self.creators = creators 123 self._pcr = pcr 124 self._operators_sequence = operators_sequence 125 self.population_size = population_size 126 self._selection_methods = selection_methods 127 self.higher_is_better = higher_is_better 128 self.evaluator = evaluator 129 130 self.n_elite = round(elitism_rate * self.population_size) 131 132 if self.n_elite == 0 and elitism_rate > 0.0: 133 logger.warning( 134 "Detected elitism_rate > 0 but 0 elites. " 135 "Try increasing elitism_rate." 136 ) 137 138 self.individuals = individuals
def
create_subpopulation_individuals(self):
140 def create_subpopulation_individuals(self): 141 if self.individuals is None: 142 # Select one creator to generate individuals, 143 # with respect to the creators' probabilities 144 145 # choices returns [selected_creator] 146 selected_creator = random.choices( 147 self.creators, weights=self._pcr 148 )[0] 149 self.individuals = selected_creator.create_individuals( 150 self.population_size, self.higher_is_better 151 )