| """ |
| TinyverseGP: A modular cross-domain benchmark system for Genetic Programming. |
| The tinyverse module includes a collections of base classes to be used by the GP modules. |
| and therefore represent the fundamental model architecture of TinyverseGP. |
| |
| - GPModel: Abstract base class for GP representations |
| - Config: Abstract base class for the GP configuration |
| - GPConfig: Basic config class that considers fundamental |
| settings needed to run GP |
| - Hyperparameters: Abstract base class for the hyperparameters |
| - GPHyperparameters: Basic HP's often needed for the configuration of GP |
| - Function: Base class for the representation of a non-terminal symbol |
| which is part of the function set |
| - Var: Derived class for the representation of variable terminal symbols |
| - Const: Derived class for the representation of const terminal symbols |
| """ |
|
|
| import random |
| import time |
| import os |
| from abc import ABC |
| from abc import abstractmethod |
| from dataclasses import dataclass, fields |
| from typing import Any, Generic, Callable |
| import copy |
|
|
| from src.gp.types import HPType |
| import yaml |
| import dill |
|
|
|
|
| class GPIndividual(ABC): |
| genome: any |
| fitness: any |
| evaluated: bool |
|
|
| """ |
| Class that is used to represent a GP individual. |
| Formally a GP individual can be represented as a tuple consisting of |
| the genome and the fitness value. |
| """ |
|
|
| def __init__(self, genome_: any = None, fitness_: any = None): |
| self.genome = genome_ |
| self.fitness = fitness_ |
|
|
| if fitness_ is None: |
| self.evaluated = False |
|
|
| def list(self): |
| return [self.genome, self.fitness] |
|
|
| @abstractmethod |
| def serialize_genome(self): |
| pass |
|
|
| @abstractmethod |
| def deserialize_genome(self): |
| pass |
|
|
|
|
| @dataclass |
| class Config(ABC): |
| """ |
| Abstract class for configuration classes. |
| """ |
|
|
| def as_dict(self) -> dict: |
| return self.__dict__ |
|
|
| @classmethod |
| def from_dict(cls, d: dict): |
| names = {field.name for field in fields(cls)} |
| return cls(**{k: v for k, v in d.items() if k in names}) |
|
|
|
|
| @dataclass(kw_only=True) |
| class GPConfig(Config): |
| """ |
| Configuration class for GP models. |
| This class contains the common configuration parameters for GP models related to |
| execution and output of a run. |
| """ |
|
|
| global_seed: int |
| num_jobs: int |
| max_generations: int |
| stopping_criteria: float |
| minimizing_fitness: bool |
| ideal_fitness: float |
| silent_algorithm: bool |
| silent_evolver: bool |
| minimalistic_output: bool |
| num_outputs: int |
| report_interval: int |
| max_time: int |
| constraints: Callable[[Any], float] = lambda x: 0.0 |
| checkpointing: bool = False |
| checkpoint_interval: int = 0 |
| checkpoint_dir: str = "" |
| experiment_name: str = "" |
|
|
|
|
| @dataclass |
| class Hyperparameter(ABC, Generic[HPType]): |
| name: str |
| lower: HPType |
| upper: HPType |
| type: HPType |
|
|
|
|
| @dataclass |
| class HyperparameterSpace(ABC): |
| space: list[Hyperparameter] |
|
|
|
|
| @dataclass(kw_only=True) |
| class Hyperparameters(ABC): |
| """ |
| Base class for the GP hyperparamters. |
| """ |
|
|
| penalization_complexity_factor: float = 0.0 |
| penalization_feasibility_factor: float = 0.0 |
| penalization_validity_factor: float = 0.0 |
| discard_invalid: bool = True |
| discard_infeasible: bool = False |
|
|
| def __post_init__(self): |
| self.space = dict() |
|
|
| def to_yaml(self): |
| with open("hp.yml", "w") as file: |
| yaml.dump(self.space, file, default_flow_style=False) |
|
|
| def as_dict(self): |
| return self.__dict__ |
|
|
| @classmethod |
| def from_dict(cls, d: dict): |
| names = {field.name for field in fields(cls)} |
| return cls(**{k: v for k, v in d.items() if k in names}) |
|
|
|
|
| @dataclass(kw_only=True) |
| class GPHyperparameters(Hyperparameters): |
| """ |
| Hyperparameters class for Genetic Programming models. |
| This class is responsible for storing the tunable hyperparameters of the GP model. |
| """ |
|
|
| pop_size: int |
| mutation_rate: float |
| cx_rate: float |
| tournament_size: int |
|
|
| def __post_init__(self): |
| Hyperparameters.__post_init__(self) |
| self.space["pop_size"] = (10, 5000) |
| self.space["mutation_rate"] = (0.0, 1.0) |
| self.space["cx_rate"] = (0.0, 1.0) |
| self.space["tournament_size"] = (2, 9) |
| self.space["penalization_complexity_factor"] = (0.0, 1.0) |
| self.space["penalization_feasibility_factor"] = (0.0, 1.0) |
| self.space["penalization_validity_factor"] = (0.0, 1.0) |
| self.space["discard_invalid"] = (False, True) |
| self.space["discard_infeasible"] = (False, True) |
|
|
|
|
| @dataclass |
| class Function: |
| """ |
| Main class used for representing functions, variables or constants. |
| It contains information about arity, a string representation for the function, |
| and the function itself. |
| The method `call` is used to call the function with the given arguments. |
| The method `custom` is meant to make the function compatible with sympy, if |
| None is passed, it will use the defaults. |
| """ |
|
|
| name: str |
| arity: int |
| function: callable |
| custom: callable |
|
|
| def __init__(self, arity_, name_, function_, custom_=None): |
| self.function = function_ |
| self.name = name_ |
| self.arity = arity_ |
| self.custom = custom_ |
|
|
| def __call__(self, *args) -> Any: |
| assert len(args) == self.arity |
| return self.function(*args) |
|
|
|
|
| class Var(Function): |
| """ |
| Class for representing variable terminals. |
| """ |
|
|
| def __init__(self, index: int = None, name_: str = None): |
| self.const = False |
| if name_ is None: |
| name_ = "Var" |
| Function.__init__(self, 0, name_, lambda: index) |
|
|
|
|
| class Const(Function): |
| """ |
| Class for representing constant terminals. |
| """ |
|
|
| def __init__(self, value): |
| self.const = True |
| Function.__init__(self, 0, "Const", lambda: value) |
|
|
|
|
| @dataclass |
| class GPState: |
| generation: int |
| evaluations: int |
| erc: list |
| population: list |
|
|
|
|
| class Checkpointer: |
|
|
| hyperparameters: Hyperparameters |
| config: GPConfig |
|
|
| def __init__(self, config_, hyperparameters_): |
| self.config = config_ |
| self.hyperparameters = hyperparameters_ |
| self.path = self.create_dir() |
|
|
| def write(self, state): |
|
|
| def dump_population(population): |
| pop_genome_fitness = [] |
| for ind in population: |
| pop_genome_fitness.append([ind.serialize_genome(), ind.fitness]) |
| return pop_genome_fitness |
|
|
| file_path = self.path + "/checkpoint_gen_" + str(state.generation) + ".dill" |
|
|
| checkpoint = { |
| "generation": state.generation, |
| "evaluations": state.evaluations, |
| "config": self.config.as_dict(), |
| "hyperparameters": self.hyperparameters.as_dict(), |
| "erc": state.erc, |
| "population": dump_population(state.population), |
| } |
|
|
| outfile = os.open(file_path, flags=os.O_WRONLY | os.O_CREAT | os.O_TRUNC) |
| os.write(outfile, dill.dumps(checkpoint)) |
|
|
| def load(self, file): |
| with open(file, "rb") as infile: |
| checkpoint = dill.load(infile) |
| if not self.config.silent_evolver: |
| print(f"Checkpoint {file} successfully loaded") |
| return checkpoint |
|
|
| def create_dir(self): |
| dir_name = ( |
| self.config.experiment_name |
| if self.config.experiment_name is not None |
| else time.time() |
| ) |
| path = os.path.join(self.config.checkpoint_dir, dir_name) |
|
|
| if not os.path.exists(path): |
| os.makedirs(path) |
|
|
| return path |
|
|
|
|
| class GPModel(ABC): |
| """ |
| Abstract based class for tiny GP representation modules. |
| It describes the minimum requirements for a GP model that is |
| integrated in the framework. |
| """ |
|
|
| best_individual: GPIndividual |
| num_evaluations: int |
| generation_number: int |
| population: list[GPIndividual] |
| erc: list |
| hyperparameters: GPHyperparameters |
| config: GPConfig |
|
|
| def __init__(self, config_: GPConfig, hyperparameters_: GPHyperparameters): |
| |
| self.config = config_ |
| self.hyperparameters = hyperparameters_ |
| self.erc = [] |
| self.checkpointer = Checkpointer(self.config, self.hyperparameters) |
| self.generation_number = 0 |
| self.num_evaluations = 0 |
| random.seed(self.config.global_seed) |
|
|
| @abstractmethod |
| def init_population(self): |
| """ |
| Creates the population the way it is done for the respective GP representation. |
| """ |
| pass |
|
|
| def evaluate(self, problem) -> GPIndividual: |
| """ |
| Evaluates the population. |
| |
| :returns: the best solution discovered in the population |
| """ |
| best = None |
| for individual in self.population: |
| self.num_evaluations += 1 |
| genome = individual.genome |
| if individual.fitness is None: |
| |
| if self.__class__.__name__ == 'Tiny3GE': |
| individual.fitness = self.penalize( |
| self.evaluate_individual(individual, problem), individual |
| ) |
| else: |
| individual.fitness = self.penalize( |
| self.evaluate_individual(genome, problem), genome |
| ) |
| fitness = individual.fitness |
|
|
| if best is None: |
| best = copy.copy(individual) |
| best_fitness = fitness |
|
|
| if problem.is_better(fitness, best_fitness): |
| best = copy.copy(individual) |
| best_fitness = fitness |
|
|
| self.best_individual = copy.copy(best) |
|
|
| return best |
|
|
| def penalize(self, fitness: float, genome: GPIndividual) -> float: |
| """ |
| Penalizes the fitness of a genome. |
| This method is used to penalize genomes that are |
| invalid, do not satisfy the constraints of the problem, or are too complex. |
| """ |
| valid = self.is_valid(genome) |
| if self.hyperparameters.discard_invalid and not valid: |
| if self.config.minimizing_fitness: |
| return float("inf") |
| else: |
| return float("-inf") |
| violations = self.config.constraints(genome) |
| if self.hyperparameters.discard_infeasible and violations > 0: |
| if self.config.minimizing_fitness: |
| return float("inf") |
| else: |
| return float("-inf") |
| complexity = self.eval_complexity(genome) |
|
|
| penalty = ( |
| self.hyperparameters.penalization_complexity_factor * complexity |
| + self.hyperparameters.penalization_feasibility_factor * violations |
| + self.hyperparameters.penalization_validity_factor * (1.0 - valid) |
| ) |
|
|
| if self.config.minimizing_fitness: |
| fitness += penalty |
| else: |
| fitness -= penalty |
| return fitness |
|
|
| @abstractmethod |
| def is_valid(self, genome: GPIndividual) -> bool: |
| """ |
| Checks if the genome is valid. |
| """ |
| pass |
|
|
| @abstractmethod |
| def eval_complexity(self, genome: GPIndividual) -> float: |
| """ |
| Evaluates the complexity of the genome. |
| """ |
| pass |
|
|
| @abstractmethod |
| def evaluate_individual(self, genome: GPIndividual) -> float: |
| """ |
| Fitness function that evaluates a single individual. |
| """ |
| pass |
|
|
| @abstractmethod |
| def pipeline(self, problem): |
| """ |
| Function that executes a single step of the evolutionary process. |
| """ |
| pass |
|
|
|
|
| def reset(self): |
| """ |
| Resets the population and the counters. |
| If multiple instances should be executed with different seeds |
| the rng is re-seeded. |
| """ |
|
|
| self.init_population() |
|
|
| self.num_evaluations = 0 |
| self.generation_number = 0 |
|
|
| |
| |
| if self.config.num_jobs > 1 and self.config.global_seed is None: |
| random.seed() |
|
|
|
|
| def evolve(self, problem) -> Any: |
| """ |
| Main evolution loop that is used to run instances |
| of a GP model. |
| |
| The method can report the current state generation or/and |
| job-wise. The best solution of the job is returned after all jobs have been |
| completed. |
| """ |
| best_individual = None |
| best_fitness = None |
|
|
| for job in range(self.config.num_jobs): |
|
|
| |
| self.reset() |
|
|
| t0 = time.time() |
| elapsed = 0 |
| terminate = False |
|
|
| |
| best_individual = self.evaluate(problem) |
| best_fitness = best_fitness_job = best_individual.fitness |
|
|
| while self.generation_number < self.config.max_generations: |
|
|
| best_gen = self.pipeline(problem) |
| best_gen_fitness = best_gen.fitness |
|
|
| if problem.is_better(best_gen_fitness, best_fitness): |
| best_individual = best_gen |
| best_fitness = best_gen_fitness |
|
|
| if problem.is_better(best_gen_fitness, best_fitness_job): |
| best_fitness_job = best_gen_fitness |
|
|
| self.report_generation( |
| silent_algorithm=self.config.silent_algorithm, |
| generation=self.generation_number, |
| best_fitness=best_fitness, |
| report_interval=self.config.report_interval, |
| ) |
|
|
| if self.config.checkpointing: |
| if ( |
| self.generation_number > 0 |
| and self.generation_number % self.config.checkpoint_interval == 0 |
| ): |
| self.checkpointer.write(self.state()) |
|
|
| if problem.is_ideal(best_gen_fitness): |
| if not self.config.silent_algorithm: |
| print( |
| f"Ideal fitness found in generation {self.generation_number}" |
| ) |
| break |
|
|
| if problem.is_stop(): |
| if not self.config.silent_algorithm: |
| print( |
| "Stop condition has been triggered" |
| ) |
| break |
|
|
| if ( |
| self.generation_number & 15 |
| ) == 0: |
| t1 = time.time() |
| delta = t1 - t0 |
| t0 = t1 |
| elapsed += delta |
| if elapsed + delta >= self.config.max_time: |
| if not self.config.silent_algorithm: |
| print("Timelimit exceeded") |
| break |
|
|
| self.generation_number += 1 |
|
|
| self.report_job( |
| job=job, |
| num_evaluations=self.num_evaluations, |
| best_fitness=best_fitness_job, |
| silent_evolver=self.config.silent_evolver, |
| minimalistic_output=self.config.minimalistic_output, |
| ) |
|
|
| if terminate: |
| break |
|
|
| return best_individual |
| |
| @abstractmethod |
| def selection(self) -> Any: |
| """ |
| Implementation of the selection mechanism. |
| Commonly returns an individual object or the position |
| of an individual in the population. |
| """ |
| pass |
|
|
| @abstractmethod |
| def predict(self) -> Any: |
| """ |
| The respective prediction method is implemented here. |
| """ |
| pass |
|
|
| @abstractmethod |
| def expression(self) -> Any: |
| """ |
| Returns a human-readable solution of a evolved candidate solution. |
| Return value can be a string or a list of strings. |
| """ |
| pass |
|
|
| def state(self) -> GPState: |
| return GPState( |
| erc=self.erc, |
| population=self.population, |
| generation=self.generation_number, |
| evaluations=self.num_evaluations, |
| ) |
|
|
| def resume(self, checkpoint, problem): |
| self.generation_number = checkpoint["generation"] |
| self.num_evaluations = checkpoint["evaluations"] |
| population = checkpoint["population"] |
|
|
| for idx, ind in enumerate(population): |
| self.population[idx].deserialize_genome(ind[0]) |
| self.population[idx].fitness = ind[1] |
|
|
| if not self.config.silent_evolver: |
| print(f"Resuming from generation {self.generation_number}") |
| self.evolve(problem) |
|
|
| def report_job( |
| self, |
| job: int, |
| num_evaluations: int, |
| best_fitness: float, |
| silent_evolver: bool, |
| minimalistic_output: bool, |
| ): |
| """ |
| Report the status of a job after has been executed. |
| |
| :param job: job number |
| :param num_evaluations: Number of evaluations the run lasted |
| :param best_fitness: Best fitness found during the run |
| :param silent_evolver: Switch for activating/deactivating the report function |
| :param minimalistic_output: Swith for minimalistic output |
| :return: |
| """ |
| if not silent_evolver: |
| if not minimalistic_output: |
| print( |
| "Job #" |
| + str(job) |
| + " - Evaluations: " |
| + str(num_evaluations) |
| + " - Best Fitness: " |
| + str(best_fitness) |
| ) |
| else: |
| print(str(num_evaluations) + ";" + str(best_fitness)) |
|
|
| def report_generation( |
| self, |
| silent_algorithm: bool, |
| generation: int, |
| best_fitness: float, |
| report_interval: int, |
| ): |
| """ |
| Reports the status of a generation. |
| |
| :param silent_algorithm: Switch for activating/deactivating the report function |
| :param generation: Generation number |
| :param best_fitness: Best fitness found so far |
| :param report_interval: Interval after which the generation status is reported |
| """ |
| if not silent_algorithm and generation % report_interval == 0: |
| print( |
| "Generation #" |
| + str(generation) |
| + " - Best Fitness: " |
| + str(best_fitness) |
| ) |
|
|
