eckity.genetic_encodings.ga.vector_individual

This module implements the vector class.

  1"""
  2This module implements the vector class.
  3"""
  4
  5from abc import abstractmethod
  6from random import randint
  7import logging
  8
  9from eckity.individual import Individual
 10
 11logger = logging.getLogger(__name__)
 12
 13
 14class Vector(Individual):
 15    """
 16    A Vector individual representation for Genetic Algorithms operations.
 17    It is represented by a list of values (integers, floats, etc.)
 18
 19    Parameters
 20    ----------
 21    fitness : Fitness
 22        Fitness handler class, responsible of keeping the fitness value of the individual.
 23
 24    length : int
 25        Vector length - the number of cells in the vector.
 26
 27    bounds : list of tuples
 28        Min/Max values for each vector cell (if of length n), or the minimum and maximum (if of length 1).
 29    """
 30
 31    def __init__(
 32        self, fitness, bounds, length, vector=None, update_parents=False
 33    ):
 34        super().__init__(fitness, update_parents=update_parents)
 35
 36        if (type(bounds) == tuple and len(bounds) != 2) or (
 37            type(bounds) == list and len(bounds) != length
 38        ):
 39            raise ValueError(
 40                f"Bounds must be either a tuple of size 2 or a list of {length} tuples"
 41            )
 42
 43        self.bounds = bounds
 44        self.length = length
 45
 46        if vector is None:
 47            self.vector = []
 48
 49        else:
 50            if not isinstance(vector, list):
 51                raise ValueError(
 52                    f"Expected vector argument in Vector constructor to be a list, got {type(vector)}"
 53                )
 54            if len(vector) != length:
 55                raise ValueError(
 56                    f"Expected vector argument in Vector constructor to be of length {length}, got {len(vector)}"
 57                )
 58            self.vector = vector
 59
 60    def size(self):
 61        """
 62        Compute size of vector.
 63
 64        Returns
 65        -------
 66        int
 67            vector size (= number of cells).
 68        """
 69        return len(self.vector)
 70
 71    def get_bounds(self):
 72        """
 73        Get vector bounds
 74
 75        Returns
 76        -------
 77        tuple of (Number, Number)
 78            vector bounds.
 79        """
 80        return self.bounds
 81
 82    def check_if_in_bounds(self):
 83        """
 84        Check if all vector cells are in bounds
 85
 86        Returns
 87        -------
 88        bool
 89            True if all vector cells are in bounds, False otherwise
 90        """
 91        for i in range(self.size()):
 92            if len(self.bounds) == 2:
 93                if (self.vector[i] < self.bounds[0]) or (
 94                    self.vector[i] > self.bounds[1]
 95                ):
 96                    return False
 97            else:
 98                if (self.vector[i] < self.bounds[i][0]) or (
 99                    self.vector[i] > self.bounds[i][1]
100                ):
101                    return False
102        return True
103
104    def add_cell(self, cell):
105        """
106        Add a new cell to the vector (and increase its size by 1)
107
108        Returns
109        -------
110        None
111        """
112        self.vector.append(cell)
113        self.length += 1
114
115    def empty_vector(self):
116        """
117        Convert the vector to an empty vector
118
119        Returns
120        -------
121        None
122        """
123        self.vector = []
124        self.length = 0
125
126    def set_vector(self, vector):
127        """
128        Set genome to the given vector genome
129
130        Parameters
131        -------
132        vector: list
133            `other` vector genome
134
135        Returns
136        -------
137        None
138        """
139        self.vector = vector
140        self.length = len(vector)
141
142    def get_vector(self):
143        """
144        Return self vector genome
145
146        Returns
147        -------
148        list
149            vector genome
150        """
151        return self.vector
152
153    def random_vector_part(self):
154        """
155        Get a random part of the vector
156
157        Returns
158        -------
159        list
160            sub-vector genome
161        """
162        # todo add tests to make sure this logic works
163        rnd_i = randint(0, self.size() - 1)
164        end_i = randint(rnd_i, self.size() - 1)
165        return self.vector[rnd_i : end_i + 1]
166
167    def replace_vector_part_random(self, inserted_part):
168        """
169        Replace a given vector part in a random position
170
171        Parameters
172        -------
173        inserted_part: list
174            new vector part to be inserted
175
176        Returns
177        -------
178        list
179            previous vector part of this vector genome
180        """
181        index = randint(
182            0, self.size() - len(inserted_part)
183        )  # select a random index
184        end_i = index + len(inserted_part)
185        replaced_part = self.vector[index:end_i]
186        self.vector = self.vector[:index] + inserted_part + self.vector[end_i:]
187        return replaced_part
188
189    def replace_vector_part(self, inserted_part, start_index):
190        """
191        Replace a given vector part in a given position
192
193        Parameters
194        -------
195        inserted_part: list
196            new vector part to be inserted
197
198        start_index: int
199            starting position to insert the new vector part from
200
201        Returns
202        -------
203        list
204            previous vector part of this vector genome
205        """
206        end_i = start_index + len(inserted_part)
207        replaced_part = self.vector[start_index:end_i]
208        self.vector = (
209            self.vector[:start_index] + inserted_part + self.vector[end_i:]
210        )
211        return replaced_part
212
213    def get_vector_part(self, index, end_i):
214        """
215        Return vector part from `index` to `end_i`
216
217        Parameters
218        -------
219        index: int
220            starting index
221
222        end_i: int
223            end index
224
225        Returns
226        -------
227        list
228            sub-vector genome
229        """
230        return self.vector[index:end_i]
231
232    def cell_value(self, index):
233        """
234        Get vector cell value in a given index
235
236        Parameters
237        -------
238        index: int
239            cell index
240
241        Returns
242        -------
243        object
244            vector cell value
245        """
246        return self.vector[index]
247
248    def set_cell_value(self, index, value):
249        """
250        Set vector cell value in a given index
251
252        Parameters
253        -------
254        index: int
255            cell index
256
257        value: object
258            new cell value
259
260        Returns
261        -------
262        None
263        """
264        self.vector[index] = value
265
266    @abstractmethod
267    def get_random_number_in_bounds(self, index):
268        """
269        Returns a random value in vector bounds
270
271        Parameters
272        -------
273        index: int
274            cell index
275
276        Returns
277        -------
278        object
279            vector cell value
280        """
281        raise NotImplementedError(
282            "get_random_number is an abstract method in vector individual"
283        )
284
285    def execute(self, *args, **kwargs):
286        """
287        Execute the vector.
288        Input is a numpy array or keyword arguments (but not both).
289
290        Parameters
291        ----------
292        args : arguments
293            A numpy array, this is mostly relevant to GP representation.
294
295        kwargs : keyword arguments
296            Input to program, this is mostly relevant to GP representation.
297
298        Returns
299        -------
300        object
301            Vector (genome) of this individual.
302        """
303        return self.get_vector()
304
305    def show(self):
306        """
307        Print out a simple textual representation of the vector.
308
309        Returns
310        -------
311        None.
312        """
313        logger.debug(self.vector)
314
315
316# end class Vector
class Vector(eckity.individual.Individual):
 15class Vector(Individual):
 16    """
 17    A Vector individual representation for Genetic Algorithms operations.
 18    It is represented by a list of values (integers, floats, etc.)
 19
 20    Parameters
 21    ----------
 22    fitness : Fitness
 23        Fitness handler class, responsible of keeping the fitness value of the individual.
 24
 25    length : int
 26        Vector length - the number of cells in the vector.
 27
 28    bounds : list of tuples
 29        Min/Max values for each vector cell (if of length n), or the minimum and maximum (if of length 1).
 30    """
 31
 32    def __init__(
 33        self, fitness, bounds, length, vector=None, update_parents=False
 34    ):
 35        super().__init__(fitness, update_parents=update_parents)
 36
 37        if (type(bounds) == tuple and len(bounds) != 2) or (
 38            type(bounds) == list and len(bounds) != length
 39        ):
 40            raise ValueError(
 41                f"Bounds must be either a tuple of size 2 or a list of {length} tuples"
 42            )
 43
 44        self.bounds = bounds
 45        self.length = length
 46
 47        if vector is None:
 48            self.vector = []
 49
 50        else:
 51            if not isinstance(vector, list):
 52                raise ValueError(
 53                    f"Expected vector argument in Vector constructor to be a list, got {type(vector)}"
 54                )
 55            if len(vector) != length:
 56                raise ValueError(
 57                    f"Expected vector argument in Vector constructor to be of length {length}, got {len(vector)}"
 58                )
 59            self.vector = vector
 60
 61    def size(self):
 62        """
 63        Compute size of vector.
 64
 65        Returns
 66        -------
 67        int
 68            vector size (= number of cells).
 69        """
 70        return len(self.vector)
 71
 72    def get_bounds(self):
 73        """
 74        Get vector bounds
 75
 76        Returns
 77        -------
 78        tuple of (Number, Number)
 79            vector bounds.
 80        """
 81        return self.bounds
 82
 83    def check_if_in_bounds(self):
 84        """
 85        Check if all vector cells are in bounds
 86
 87        Returns
 88        -------
 89        bool
 90            True if all vector cells are in bounds, False otherwise
 91        """
 92        for i in range(self.size()):
 93            if len(self.bounds) == 2:
 94                if (self.vector[i] < self.bounds[0]) or (
 95                    self.vector[i] > self.bounds[1]
 96                ):
 97                    return False
 98            else:
 99                if (self.vector[i] < self.bounds[i][0]) or (
100                    self.vector[i] > self.bounds[i][1]
101                ):
102                    return False
103        return True
104
105    def add_cell(self, cell):
106        """
107        Add a new cell to the vector (and increase its size by 1)
108
109        Returns
110        -------
111        None
112        """
113        self.vector.append(cell)
114        self.length += 1
115
116    def empty_vector(self):
117        """
118        Convert the vector to an empty vector
119
120        Returns
121        -------
122        None
123        """
124        self.vector = []
125        self.length = 0
126
127    def set_vector(self, vector):
128        """
129        Set genome to the given vector genome
130
131        Parameters
132        -------
133        vector: list
134            `other` vector genome
135
136        Returns
137        -------
138        None
139        """
140        self.vector = vector
141        self.length = len(vector)
142
143    def get_vector(self):
144        """
145        Return self vector genome
146
147        Returns
148        -------
149        list
150            vector genome
151        """
152        return self.vector
153
154    def random_vector_part(self):
155        """
156        Get a random part of the vector
157
158        Returns
159        -------
160        list
161            sub-vector genome
162        """
163        # todo add tests to make sure this logic works
164        rnd_i = randint(0, self.size() - 1)
165        end_i = randint(rnd_i, self.size() - 1)
166        return self.vector[rnd_i : end_i + 1]
167
168    def replace_vector_part_random(self, inserted_part):
169        """
170        Replace a given vector part in a random position
171
172        Parameters
173        -------
174        inserted_part: list
175            new vector part to be inserted
176
177        Returns
178        -------
179        list
180            previous vector part of this vector genome
181        """
182        index = randint(
183            0, self.size() - len(inserted_part)
184        )  # select a random index
185        end_i = index + len(inserted_part)
186        replaced_part = self.vector[index:end_i]
187        self.vector = self.vector[:index] + inserted_part + self.vector[end_i:]
188        return replaced_part
189
190    def replace_vector_part(self, inserted_part, start_index):
191        """
192        Replace a given vector part in a given position
193
194        Parameters
195        -------
196        inserted_part: list
197            new vector part to be inserted
198
199        start_index: int
200            starting position to insert the new vector part from
201
202        Returns
203        -------
204        list
205            previous vector part of this vector genome
206        """
207        end_i = start_index + len(inserted_part)
208        replaced_part = self.vector[start_index:end_i]
209        self.vector = (
210            self.vector[:start_index] + inserted_part + self.vector[end_i:]
211        )
212        return replaced_part
213
214    def get_vector_part(self, index, end_i):
215        """
216        Return vector part from `index` to `end_i`
217
218        Parameters
219        -------
220        index: int
221            starting index
222
223        end_i: int
224            end index
225
226        Returns
227        -------
228        list
229            sub-vector genome
230        """
231        return self.vector[index:end_i]
232
233    def cell_value(self, index):
234        """
235        Get vector cell value in a given index
236
237        Parameters
238        -------
239        index: int
240            cell index
241
242        Returns
243        -------
244        object
245            vector cell value
246        """
247        return self.vector[index]
248
249    def set_cell_value(self, index, value):
250        """
251        Set vector cell value in a given index
252
253        Parameters
254        -------
255        index: int
256            cell index
257
258        value: object
259            new cell value
260
261        Returns
262        -------
263        None
264        """
265        self.vector[index] = value
266
267    @abstractmethod
268    def get_random_number_in_bounds(self, index):
269        """
270        Returns a random value in vector bounds
271
272        Parameters
273        -------
274        index: int
275            cell index
276
277        Returns
278        -------
279        object
280            vector cell value
281        """
282        raise NotImplementedError(
283            "get_random_number is an abstract method in vector individual"
284        )
285
286    def execute(self, *args, **kwargs):
287        """
288        Execute the vector.
289        Input is a numpy array or keyword arguments (but not both).
290
291        Parameters
292        ----------
293        args : arguments
294            A numpy array, this is mostly relevant to GP representation.
295
296        kwargs : keyword arguments
297            Input to program, this is mostly relevant to GP representation.
298
299        Returns
300        -------
301        object
302            Vector (genome) of this individual.
303        """
304        return self.get_vector()
305
306    def show(self):
307        """
308        Print out a simple textual representation of the vector.
309
310        Returns
311        -------
312        None.
313        """
314        logger.debug(self.vector)

A Vector individual representation for Genetic Algorithms operations. It is represented by a list of values (integers, floats, etc.)

Parameters
  • fitness (Fitness): Fitness handler class, responsible of keeping the fitness value of the individual.
  • length (int): Vector length - the number of cells in the vector.
  • bounds (list of tuples): Min/Max values for each vector cell (if of length n), or the minimum and maximum (if of length 1).
Vector(fitness, bounds, length, vector=None, update_parents=False)
32    def __init__(
33        self, fitness, bounds, length, vector=None, update_parents=False
34    ):
35        super().__init__(fitness, update_parents=update_parents)
36
37        if (type(bounds) == tuple and len(bounds) != 2) or (
38            type(bounds) == list and len(bounds) != length
39        ):
40            raise ValueError(
41                f"Bounds must be either a tuple of size 2 or a list of {length} tuples"
42            )
43
44        self.bounds = bounds
45        self.length = length
46
47        if vector is None:
48            self.vector = []
49
50        else:
51            if not isinstance(vector, list):
52                raise ValueError(
53                    f"Expected vector argument in Vector constructor to be a list, got {type(vector)}"
54                )
55            if len(vector) != length:
56                raise ValueError(
57                    f"Expected vector argument in Vector constructor to be of length {length}, got {len(vector)}"
58                )
59            self.vector = vector
bounds
length
def size(self):
61    def size(self):
62        """
63        Compute size of vector.
64
65        Returns
66        -------
67        int
68            vector size (= number of cells).
69        """
70        return len(self.vector)

Compute size of vector.

Returns
  • int: vector size (= number of cells).
def get_bounds(self):
72    def get_bounds(self):
73        """
74        Get vector bounds
75
76        Returns
77        -------
78        tuple of (Number, Number)
79            vector bounds.
80        """
81        return self.bounds

Get vector bounds

Returns
  • tuple of (Number, Number): vector bounds.
def check_if_in_bounds(self):
 83    def check_if_in_bounds(self):
 84        """
 85        Check if all vector cells are in bounds
 86
 87        Returns
 88        -------
 89        bool
 90            True if all vector cells are in bounds, False otherwise
 91        """
 92        for i in range(self.size()):
 93            if len(self.bounds) == 2:
 94                if (self.vector[i] < self.bounds[0]) or (
 95                    self.vector[i] > self.bounds[1]
 96                ):
 97                    return False
 98            else:
 99                if (self.vector[i] < self.bounds[i][0]) or (
100                    self.vector[i] > self.bounds[i][1]
101                ):
102                    return False
103        return True

Check if all vector cells are in bounds

Returns
  • bool: True if all vector cells are in bounds, False otherwise
def add_cell(self, cell):
105    def add_cell(self, cell):
106        """
107        Add a new cell to the vector (and increase its size by 1)
108
109        Returns
110        -------
111        None
112        """
113        self.vector.append(cell)
114        self.length += 1

Add a new cell to the vector (and increase its size by 1)

Returns
  • None
def empty_vector(self):
116    def empty_vector(self):
117        """
118        Convert the vector to an empty vector
119
120        Returns
121        -------
122        None
123        """
124        self.vector = []
125        self.length = 0

Convert the vector to an empty vector

Returns
  • None
def set_vector(self, vector):
127    def set_vector(self, vector):
128        """
129        Set genome to the given vector genome
130
131        Parameters
132        -------
133        vector: list
134            `other` vector genome
135
136        Returns
137        -------
138        None
139        """
140        self.vector = vector
141        self.length = len(vector)

Set genome to the given vector genome

Parameters
  • vector (list): other vector genome
Returns
  • None
def get_vector(self):
143    def get_vector(self):
144        """
145        Return self vector genome
146
147        Returns
148        -------
149        list
150            vector genome
151        """
152        return self.vector

Return self vector genome

Returns
  • list: vector genome
def random_vector_part(self):
154    def random_vector_part(self):
155        """
156        Get a random part of the vector
157
158        Returns
159        -------
160        list
161            sub-vector genome
162        """
163        # todo add tests to make sure this logic works
164        rnd_i = randint(0, self.size() - 1)
165        end_i = randint(rnd_i, self.size() - 1)
166        return self.vector[rnd_i : end_i + 1]

Get a random part of the vector

Returns
  • list: sub-vector genome
def replace_vector_part_random(self, inserted_part):
168    def replace_vector_part_random(self, inserted_part):
169        """
170        Replace a given vector part in a random position
171
172        Parameters
173        -------
174        inserted_part: list
175            new vector part to be inserted
176
177        Returns
178        -------
179        list
180            previous vector part of this vector genome
181        """
182        index = randint(
183            0, self.size() - len(inserted_part)
184        )  # select a random index
185        end_i = index + len(inserted_part)
186        replaced_part = self.vector[index:end_i]
187        self.vector = self.vector[:index] + inserted_part + self.vector[end_i:]
188        return replaced_part

Replace a given vector part in a random position

Parameters
  • inserted_part (list): new vector part to be inserted
Returns
  • list: previous vector part of this vector genome
def replace_vector_part(self, inserted_part, start_index):
190    def replace_vector_part(self, inserted_part, start_index):
191        """
192        Replace a given vector part in a given position
193
194        Parameters
195        -------
196        inserted_part: list
197            new vector part to be inserted
198
199        start_index: int
200            starting position to insert the new vector part from
201
202        Returns
203        -------
204        list
205            previous vector part of this vector genome
206        """
207        end_i = start_index + len(inserted_part)
208        replaced_part = self.vector[start_index:end_i]
209        self.vector = (
210            self.vector[:start_index] + inserted_part + self.vector[end_i:]
211        )
212        return replaced_part

Replace a given vector part in a given position

Parameters
  • inserted_part (list): new vector part to be inserted
  • start_index (int): starting position to insert the new vector part from
Returns
  • list: previous vector part of this vector genome
def get_vector_part(self, index, end_i):
214    def get_vector_part(self, index, end_i):
215        """
216        Return vector part from `index` to `end_i`
217
218        Parameters
219        -------
220        index: int
221            starting index
222
223        end_i: int
224            end index
225
226        Returns
227        -------
228        list
229            sub-vector genome
230        """
231        return self.vector[index:end_i]

Return vector part from index to end_i

Parameters
  • index (int): starting index
  • end_i (int): end index
Returns
  • list: sub-vector genome
def cell_value(self, index):
233    def cell_value(self, index):
234        """
235        Get vector cell value in a given index
236
237        Parameters
238        -------
239        index: int
240            cell index
241
242        Returns
243        -------
244        object
245            vector cell value
246        """
247        return self.vector[index]

Get vector cell value in a given index

Parameters
  • index (int): cell index
Returns
  • object: vector cell value
def set_cell_value(self, index, value):
249    def set_cell_value(self, index, value):
250        """
251        Set vector cell value in a given index
252
253        Parameters
254        -------
255        index: int
256            cell index
257
258        value: object
259            new cell value
260
261        Returns
262        -------
263        None
264        """
265        self.vector[index] = value

Set vector cell value in a given index

Parameters
  • index (int): cell index
  • value (object): new cell value
Returns
  • None
@abstractmethod
def get_random_number_in_bounds(self, index):
267    @abstractmethod
268    def get_random_number_in_bounds(self, index):
269        """
270        Returns a random value in vector bounds
271
272        Parameters
273        -------
274        index: int
275            cell index
276
277        Returns
278        -------
279        object
280            vector cell value
281        """
282        raise NotImplementedError(
283            "get_random_number is an abstract method in vector individual"
284        )

Returns a random value in vector bounds

Parameters
  • index (int): cell index
Returns
  • object: vector cell value
def execute(self, *args, **kwargs):
286    def execute(self, *args, **kwargs):
287        """
288        Execute the vector.
289        Input is a numpy array or keyword arguments (but not both).
290
291        Parameters
292        ----------
293        args : arguments
294            A numpy array, this is mostly relevant to GP representation.
295
296        kwargs : keyword arguments
297            Input to program, this is mostly relevant to GP representation.
298
299        Returns
300        -------
301        object
302            Vector (genome) of this individual.
303        """
304        return self.get_vector()

Execute the vector. Input is a numpy array or keyword arguments (but not both).

Parameters
  • args (arguments): A numpy array, this is mostly relevant to GP representation.
  • kwargs (keyword arguments): Input to program, this is mostly relevant to GP representation.
Returns
  • object: Vector (genome) of this individual.
def show(self):
306    def show(self):
307        """
308        Print out a simple textual representation of the vector.
309
310        Returns
311        -------
312        None.
313        """
314        logger.debug(self.vector)

Print out a simple textual representation of the vector.

Returns
  • None.