eckity.fitness.simple_fitness

  1from overrides import overrides
  2"""
  3This module implements the class `SimpleFitness`
  4"""
  5
  6from eckity.fitness.fitness import Fitness
  7
  8
  9class SimpleFitness(Fitness):
 10    """
 11    This class is responsible for handling the fitness score of some Individual
 12    (checking if fitness is evaluated, comparing fitness scores with other individuals etc.)
 13
 14    In the simple case, each individual holds a float fitness score
 15
 16    fitness: float
 17        the fitness score of an individual
 18
 19    higher_is_better: bool
 20        declares the fitness direction.
 21        i.e., if it should be minimized or maximized
 22    """
 23    def __init__(self,
 24                 fitness: float = None,
 25                 higher_is_better=False):
 26        is_evaluated = fitness is not None
 27        super().__init__(higher_is_better=higher_is_better, is_evaluated=is_evaluated)
 28        self.fitness: float = fitness
 29
 30    def set_fitness(self, fitness):
 31        """
 32        Updates the fitness score to `fitness`
 33
 34        Parameters
 35        ----------
 36        fitness: float
 37            the fitness score to be updated
 38        """
 39        self.fitness = fitness
 40        self._is_evaluated = True
 41
 42    @overrides
 43    def get_pure_fitness(self):
 44        """
 45        Returns the pure fitness score of the individual (before applying balancing methods like bloat control)
 46
 47        Returns
 48        ----------
 49        float
 50            fitness score of the individual
 51        """
 52        if not self._is_evaluated:
 53            raise ValueError('Fitness not evaluated yet')
 54        return self.fitness
 55
 56    @overrides
 57    def set_not_evaluated(self):
 58        """
 59        Set this fitness score status to be not evaluated
 60        """
 61        super().set_not_evaluated()
 62        self.fitness = None
 63
 64    def check_comparable_fitness_scores(self, other_fitness):
 65        """
 66        Check if `this` fitness score is comparable to `other_fitness`
 67
 68        Returns
 69        ----------
 70        bool
 71            True if fitness scores are comparable, False otherwise
 72        """
 73        if not isinstance(other_fitness, SimpleFitness):
 74            raise TypeError('Expected SimpleFitness object in better_than, got', type(other_fitness))
 75        if not self.is_fitness_evaluated() or not other_fitness.is_fitness_evaluated():
 76            raise ValueError('Fitness scores must be evaluated before comparison')
 77
 78    @overrides
 79    def better_than(self, ind, other_fitness, other_ind):
 80        """
 81        Compares between the current fitness of the individual `ind` to the fitness score `other_fitness` of `other_ind`
 82        In the simple case, compares the float fitness scores of the two individuals
 83
 84        Parameters
 85        ----------
 86        ind: Individual
 87            the individual instance that holds this Fitness instance
 88
 89        other_fitness: Fitness
 90            the Fitness instance of the `other` individual
 91
 92        other_ind: Individual
 93            the `other` individual instance which is being compared to the individual `ind`
 94
 95        Returns
 96        ----------
 97        bool
 98            True if this fitness score is better than the `other` fitness score, False otherwise
 99        """
100        self.check_comparable_fitness_scores(other_fitness)
101        return self.get_augmented_fitness(ind) > other_fitness.get_augmented_fitness(other_ind) \
102            if self.higher_is_better \
103            else self.get_augmented_fitness(ind) < other_fitness.get_augmented_fitness(other_ind)
104
105    @overrides
106    def equal_to(self, ind, other_fitness, other_ind):
107        """
108        Compares between the current fitness of the individual `ind` to the fitness score `other_fitness` of `other_ind`
109        In the simple case, compares the float fitness scores of the two individuals
110
111        Parameters
112        ----------
113        ind: Individual
114            the individual instance that holds this Fitness instance
115
116        other_fitness: Fitness
117            the Fitness instance of the `other` individual
118
119        other_ind: Individual
120            the `other` individual instance which is being compared to the individual `ind`
121
122        Returns
123        ----------
124        bool
125            True if this fitness score is equal to the `other` fitness score, False otherwise
126        """
127        self.check_comparable_fitness_scores(other_fitness)
128        return self.get_augmented_fitness(ind) == other_fitness.get_augmented_fitness(other_ind)
129
130    def __getstate__(self):
131        state = self.__dict__.copy()
132        if not self.should_cache_between_gens:
133            state['_is_evaluated'] = False
134            state['fitness'] = None
135        return state