| """ |
| Implements various problem types supported by TinyverseGP to |
| approach various problem domains with the benchmarking package. |
| |
| Currently, the following problem types are provided: |
| |
| - BlackBox: Used for symbolic regression and logic synthesis |
| - PolicySearch: Used for reinforcement learning problems |
| - ProgramSynthesis: Used for the provided coding problems |
| |
| """ |
| import gymnasium as gym |
| import numpy as np |
| from dataclasses import dataclass |
| from abc import ABC |
| from collections.abc import Callable |
| from src.benchmark.policy_search.policy_evaluation import GPAgent |
| from src.gp.tinyverse import GPModel |
| import numbers |
| import ioh |
| import atexit |
|
|
| class Problem(ABC): |
| """ |
| Abstract base class for the problems supported by TinverseGP. |
| Provides a skeleton for the child classes that provide actual |
| implementations of problems. |
| """ |
| __protected_attributes__ = ( |
| "logger", |
| "num_evaluations", |
| "reset", |
| "meta_data", |
| "log_evaluation" |
| ) |
| ideal: float |
| logger: ioh.logger.AbstractLogger |
|
|
| def __init__(self, fid, name, minimizing: bool = True, logger: ioh.logger.AbstractLogger = None): |
| self.logger = logger |
| self.minimizing = minimizing |
| self.num_evaluations = 0 |
| if logger is None: |
| return |
| self.meta_data = ioh.MetaData( |
| fid, |
| 1, |
| name, |
| 1, |
| ioh.OptimizationType.MIN if minimizing else ioh.OptimizationType.MAX, |
| ) |
| self.logger.attach_problem(self.meta_data) |
| atexit.register(self.logger.close) |
|
|
|
|
| def log_evaluation(self, f1, x): |
| self.num_evaluations += 1 |
| if self.logger is None: |
| return |
| info = ioh.LogInfo( |
| self.num_evaluations, |
| f1, |
| 0, |
| 0, |
| 0, |
| 0, |
| 0, |
| [0], |
| [], |
| [], |
| ioh.iohcpp.RealSolution([], 0), |
| True, |
| ) |
| self.logger.call(info) |
|
|
| def reset(self): |
| self.num_evaluations = 0 |
| if self.logger is None: |
| return |
| self.logger.reset() |
| self.logger.attach_problem(self.meta_data) |
|
|
| def is_ideal(self, fitness: float) -> bool: |
| """ |
| Check if the fitness reached an ideal state. |
| This can prompt an early stop in the optimization process. |
| |
| :param fitness: fitness of the candidate individual |
| :return: ideal fitness status |
| """ |
| return fitness <= self.ideal if self.minimizing else fitness >= self.ideal |
|
|
| def is_better(self, fitness1: float, fitness2: float) -> bool: |
| """ |
| Check if the first fitness is better than the second. |
| It takes into consideration whether the problem is minimizing or maximizing. |
| |
| :param fitness1: fitness of the first individual |
| :param fitness2: fitness of the second individual |
| :return: status if fitness1 is better than fitness2 |
| """ |
| return fitness1 < fitness2 if self.minimizing else fitness1 > fitness2 |
|
|
| def evaluate(self, genome, model: GPModel): |
| """ |
| This method implements how to evaluate the genome using the model. |
| It is problem-specific and should be implemented by the user. |
| |
| :param genome: Genome of the individual |
| :param model: The respective GP model that is used |
| """ |
| pass |
| |
| def is_stop(self): |
| """ |
| Check for additional stop conditions besides the optimum of the defined problem. |
| By default, there are no additional stop conditions in place. |
| """ |
| return False |
| |
| def __del__(self, *args, **kwargs): |
| if self.logger is not None: |
| self.logger.close() |
|
|
| @dataclass |
| class BlackBox(Problem): |
| """ |
| Represents a black-box problem where the fitness is calculated by a loss function |
| on a dataset of observations and the actual (objective) function values. |
| """ |
|
|
| observations: list |
| actual: list |
|
|
| def __init__( |
| self, |
| observations_: list, |
| actual_: list, |
| loss_: Callable[[list, list], float], |
| ideal_: float, |
| minimizing_: bool, |
| fid: int = 1, |
| name: str = "None", |
| logger: ioh.logger.AbstractLogger = None |
| ): |
| super().__init__(fid, name, minimizing_, logger=logger) |
| self.observations = observations_ |
| self.actual = actual_ |
| self.loss = loss_ |
| self.ideal = ideal_ |
| self.minimizing = minimizing_ |
| self.unidim = True if isinstance(self.actual[0], numbers.Number) else False |
|
|
| def evaluate(self, genome, model: GPModel) -> float: |
| """ |
| Evaluates the genome of a GP individual on the dataset with the |
| given GP model. |
| |
| The predictions made by the model are used to calculate the cost |
| function value. |
| |
| :param genome: Genome of the individual |
| :param model: Selected GP model |
| |
| :return: cost function value |
| """ |
| predictions = [] |
| for observation in self.observations: |
| prediction = model.predict(genome, observation) |
| predictions.append(prediction) |
| result = self.cost(predictions) |
| self.log_evaluation(result, genome) |
| return result |
| |
| def cost(self, predictions: list) -> float: |
| """ |
| Calculates the cost function value based on the |
| selected loss function that has been passed to the class. |
| |
| :param predictions: Set of predictions made by the model |
| :return: cost function value |
| """ |
| cost = 0.0 |
|
|
| for index, _ in enumerate(predictions[0]): |
| cost += self.loss( |
| [prediction[index] for prediction in predictions], |
| [act if self.unidim else act[index] for act in self.actual], |
| ) |
| return cost |
|
|
|
|
| class PolicySearch(Problem): |
| """ |
| Representation of the policy search problem where the fitness is calculated by the |
| average reward of the policy. |
| |
| A instance of the GPAgent class is used to evaluate a candidate policy within the respective |
| environment. |
| """ |
|
|
| agent: GPAgent |
| num_episodes: int |
| max_steps: int |
| step_cnt: int |
| frames_per_step = int |
|
|
| def __init__( |
| self, env: gym.Env, ideal_: float, minimizing_: bool, num_episodes_: int = 100, |
| frames_per_step_: int = 1, |
| max_steps_: float = 2e6, fid: int = 1, name: str = "None", logger: ioh.logger.AbstractLogger = None): |
| super().__init__(fid=fid, name=name, minimizing=minimizing_, logger=logger) |
| self.agent = GPAgent(env) |
| self.ideal = ideal_ |
| self.minimizing = minimizing_ |
| self.num_episodes = num_episodes_ |
| self.frames_per_step = frames_per_step_ |
| self.max_steps = int(max_steps_) |
| self.step_cnt = 0 |
|
|
| def is_stop(self): |
| return self.step_cnt >= self.max_steps |
|
|
| def evaluate( |
| self, genome, model: GPModel, num_episodes: int = None, wait_key: bool = False |
| ) -> float: |
| if num_episodes is None: |
| num_episodes = self.num_episodes |
| reward, num_steps = self.agent.evaluate_policy(genome, model, num_episodes, wait_key) |
|
|
| if self.frames_per_step is not None: |
| self.step_cnt += num_steps * self.frames_per_step |
| else: |
| self.step_cnt += num_steps |
| self.log_evaluation(reward, genome) |
| return reward |
|
|
|
|
| class ProgramSynthesis(Problem): |
| """ |
| Represent a program synthesis problem where the evaluation is based on a dataset |
| that consists of positive examples and counterexamples. |
| |
| The predictions are made with a binary step activation function and the cost function |
| is based on the hamming distance between the binary predictions and the actual values in the |
| dataset. |
| """ |
|
|
| def __init__(self, dataset_, minimizing_: bool = False, |
| fid: int = 1, name: str = "None", logger: ioh.logger.AbstractLogger = None): |
| super().__init__(fid=fid, name=name, minimizing=minimizing_, logger=logger) |
| self.dataset = dataset_ |
| self.minimizing = minimizing_ |
|
|
| def is_ideal(self, fitness): |
| return fitness == len(self.dataset) |
|
|
| def sigmoid(self, x): |
| return 1 / (1 + np.exp(-x)) |
|
|
| def binary_step(self, x, threshold=0.5): |
| return 0 if self.sigmoid(x) <= threshold else 1 |
|
|
| def evaluate(self, genome, model): |
| predictions = [] |
| for observation in self.dataset: |
| prediction = model.predict(genome, observation) |
| prediction = self.binary_step(prediction[0]) |
| predictions.append(prediction) |
| result = self.cost(predictions) |
| self.log_evaluation(result, genome) |
| return result |
|
|
| def cost(self, predictions): |
| cost = 0 |
| for i, prediction in enumerate(predictions): |
| cost += 1 if prediction == self.dataset[i][1] else 0 |
| return cost |
|
|
