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
creators
population_size
higher_is_better
evaluator
n_elite
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            )
def get_operators_sequence(self):
153    def get_operators_sequence(self):
154        return self._operators_sequence
def get_selection_methods(self):
156    def get_selection_methods(self):
157        return self._selection_methods
def get_best_individual(self):
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]
def get_worst_individual(self):
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]
def get_average_fitness(self):
175    def get_average_fitness(self):
176        return np.mean(
177            [indiv.get_pure_fitness() for indiv in self.individuals]
178        )
def contains_individual(self, individual):
180    def contains_individual(self, individual):
181        return individual in self.individuals