遗传算法中适值函数的标定与大变异算法

def linear_scaling(self, target='max', ksi=0.5):
    '''
    A decorator constructor for fitness function linear scaling.

    :param target: The optimization target, maximization or minimization.
    :type target: str, 'max' or 'min'

    :param ksi: Selective pressure adjustment value.
    :type ksi: float

    Linear Scaling:
        1. arg max f(x), then f' = f - min{f(x)} + ksi;
        2. arg min f(x), then f' = max{f(x)} - f(x) + ksi;
    '''
    def _linear_scaling(fn):
        # For original fitness calculation.
        self.ori_fitness = fn

        @wraps(fn)
        def _fn_with_linear_scaling(indv):
            # Original fitness value.
            f = fn(indv)

            # Determine the value of a and b.
            if target == 'max':
                f_prime = f - self.ori_fmin + ksi
            elif target == 'min':
                f_prime = self.ori_fmax - f + ksi
            else:
                raise ValueError('Invalid target type({})'.format(target))
            return f_prime

        return _fn_with_linear_scaling

    return _linear_scaling

# Create a GA engine...

# 先标定，后注册到引擎中
@engine.fitness_register
@engine.linear_scaling(target='min', ksi=0.5)
def fitness(indv):
    x, = indv.variants
    return x + 10*sin(5*x) + 7*cos(4*x)

def dynamic_linear_scaling(self, target='max', ksi0=2, r=0.9):
    '''
    A decorator constructor for fitness dynamic linear scaling.

    :param target: The optimization target, maximization or minimization.
    :type target: str, 'max' or 'min'

    :param ksi0: Initial selective pressure adjustment value, default value
                 is 2
    :type ksi0: float

    :param r: The reduction factor for selective pressure adjustment value,
              ksi^(k-1)*r is the adjustment value for generation k, default
              value is 0.9
    :type r: float in range [0.9, 0.999]

    Dynamic Linear Scaling:
        For maximizaiton, f' = f(x) - min{f(x)} + ksi^k, k is generation number.
    '''
    def _dynamic_linear_scaling(fn):
        # For original fitness calculation.
        self.ori_fitness = fn

        @wraps(fn)
        def _fn_with_dynamic_linear_scaling(indv):
            f = fn(indv)
            k = self.current_generation + 1

            if target == 'max':
                f_prime = f - self.ori_fmin + ksi0*(r**k)
            elif target == 'min':
                f_prime = self.ori_fmax - f + ksi0*(r**k)
            else:
                raise ValueError('Invalid target type({})'.format(target))
            return f_prime

        return _fn_with_dynamic_linear_scaling

    return _dynamic_linear_scaling

@engine.fitness_register
@engine.dynamic_linear_scaling(target='max', ksi0=2, r=0.9)
def fitness(indv):
    x, = indv.variants
    return x + 10*sin(5*x) + 7*cos(4*x)

class FlipBitBigMutation(FlipBitMutation):
    def __init__(self, pm, pbm, alpha):
        '''
        Mutation operator using Flip Bit mutation implementation with adaptive
        big mutation rate to overcome premature or local-best solution.

        :param pm: The probability of mutation (usually between 0.001 ~ 0.1)
        :type pm: float in (0.0, 1.0]

        :param pbm: The probability of big mutation, usually more than 5 times
                    bigger than pm.
        :type pbm: float

        :param alpha: intensive factor
        :type alpha: float, in range (0.5, 1)
        '''
        super(self.__class__, self).__init__(pm)

        if not (0.0 < pbm < 1.0):
            raise ValueError('Invalid big mutation probability')
        if pbm < 5*pm:
            self.logger.warning('Relative low probability for big mutation')
        self.pbm = pbm

        # Intensive factor.
        if not (0.5 < alpha < 1.0):
            raise ValueError('Invalid intensive factor, should be in (0.5, 1.0)')
        self.alpha = alpha

    def mutate(self, individual, engine):
        '''
        Mutate the individual with adaptive big mutation rate.
        '''
        pm = self.pm

        if engine.fmax*self.alpha < engine.fmean:
            self.pm = self.pbm
            self.logger.info('Big mutation probabilty: {} -> {}'.format(pm, self.pm))

        # Mutate with big probability.
        individual = super(self.__class__, self).mutate(individual, engine)

        # Recover probability.
        self.pm = pm

        return individual