eckity.creators.ga_creators.simple_vector_creator

 1from eckity.creators.creator import Creator
 2from eckity.fitness.simple_fitness import SimpleFitness
 3from eckity.genetic_encodings.ga.bit_string_vector import BitStringVector
 4
 5
 6class GAVectorCreator(Creator):
 7    def __init__(
 8        self,
 9        length=1,
10        gene_creator=None,
11        bounds=(0.0, 1.0),
12        vector_type=BitStringVector,
13        fitness_type=SimpleFitness,
14        events=None,
15        update_parents=False,
16    ):
17        if events is None:
18            events = ["after_creation"]
19        super().__init__(events, fitness_type)
20
21        if gene_creator is None:
22            gene_creator = self.default_gene_creator
23        self.gene_creator = gene_creator
24
25        self.type = vector_type
26        self.length = length
27        self.bounds = bounds
28        self.update_parents = update_parents
29
30    def create_individuals(self, n_individuals, higher_is_better):
31        individuals = [
32            self.type(
33                length=self.length,
34                bounds=self.bounds,
35                fitness=self.fitness_type(higher_is_better=higher_is_better),
36                update_parents=self.update_parents,
37            )
38            for _ in range(n_individuals)
39        ]
40        for ind in individuals:
41            self.create_vector(ind)
42        self.created_individuals = individuals
43
44        return individuals
45
46    def create_vector(self, individual):
47        # vector = [self.gene_creator(individual.bounds[i % len(individual.bounds)]) for i in individual.size()]
48        vector = [self.gene_creator(individual, i) for i in range(self.length)]
49        individual.set_vector(vector)
50
51    @staticmethod
52    def default_gene_creator(individual, index):
53        return individual.get_random_number_in_bounds(index)
class GAVectorCreator(eckity.creators.creator.Creator):
 7class GAVectorCreator(Creator):
 8    def __init__(
 9        self,
10        length=1,
11        gene_creator=None,
12        bounds=(0.0, 1.0),
13        vector_type=BitStringVector,
14        fitness_type=SimpleFitness,
15        events=None,
16        update_parents=False,
17    ):
18        if events is None:
19            events = ["after_creation"]
20        super().__init__(events, fitness_type)
21
22        if gene_creator is None:
23            gene_creator = self.default_gene_creator
24        self.gene_creator = gene_creator
25
26        self.type = vector_type
27        self.length = length
28        self.bounds = bounds
29        self.update_parents = update_parents
30
31    def create_individuals(self, n_individuals, higher_is_better):
32        individuals = [
33            self.type(
34                length=self.length,
35                bounds=self.bounds,
36                fitness=self.fitness_type(higher_is_better=higher_is_better),
37                update_parents=self.update_parents,
38            )
39            for _ in range(n_individuals)
40        ]
41        for ind in individuals:
42            self.create_vector(ind)
43        self.created_individuals = individuals
44
45        return individuals
46
47    def create_vector(self, individual):
48        # vector = [self.gene_creator(individual.bounds[i % len(individual.bounds)]) for i in individual.size()]
49        vector = [self.gene_creator(individual, i) for i in range(self.length)]
50        individual.set_vector(vector)
51
52    @staticmethod
53    def default_gene_creator(individual, index):
54        return individual.get_random_number_in_bounds(index)

Helper class that provides a standard way to create an ABC using inheritance.

GAVectorCreator( length=1, gene_creator=None, bounds=(0.0, 1.0), vector_type=<class 'eckity.genetic_encodings.ga.bit_string_vector.BitStringVector'>, fitness_type=<class 'eckity.fitness.simple_fitness.SimpleFitness'>, events=None, update_parents=False)
 8    def __init__(
 9        self,
10        length=1,
11        gene_creator=None,
12        bounds=(0.0, 1.0),
13        vector_type=BitStringVector,
14        fitness_type=SimpleFitness,
15        events=None,
16        update_parents=False,
17    ):
18        if events is None:
19            events = ["after_creation"]
20        super().__init__(events, fitness_type)
21
22        if gene_creator is None:
23            gene_creator = self.default_gene_creator
24        self.gene_creator = gene_creator
25
26        self.type = vector_type
27        self.length = length
28        self.bounds = bounds
29        self.update_parents = update_parents
gene_creator
type
length
bounds
update_parents
def create_individuals(self, n_individuals, higher_is_better):
31    def create_individuals(self, n_individuals, higher_is_better):
32        individuals = [
33            self.type(
34                length=self.length,
35                bounds=self.bounds,
36                fitness=self.fitness_type(higher_is_better=higher_is_better),
37                update_parents=self.update_parents,
38            )
39            for _ in range(n_individuals)
40        ]
41        for ind in individuals:
42            self.create_vector(ind)
43        self.created_individuals = individuals
44
45        return individuals
def create_vector(self, individual):
47    def create_vector(self, individual):
48        # vector = [self.gene_creator(individual.bounds[i % len(individual.bounds)]) for i in individual.size()]
49        vector = [self.gene_creator(individual, i) for i in range(self.length)]
50        individual.set_vector(vector)
@staticmethod
def default_gene_creator(individual, index):
52    @staticmethod
53    def default_gene_creator(individual, index):
54        return individual.get_random_number_in_bounds(index)