数值算例测试 about gaft HOT 4 OPEN

from PyOptimize.General_Opt import Optimizer

from gaft import GAEngine
from gaft.components import GAIndividual
from gaft.components import GAPopulation
from gaft.operators import TournamentSelection
from gaft.operators import UniformCrossover
from gaft.operators import FlipBitBigMutation

# Built-in best fitness analysis.
from gaft.analysis.fitness_store import FitnessStore
from gaft.plugin_interfaces.analysis import OnTheFlyAnalysis

class pyGaft(Optimizer):
    def __init__(self, objfunc, var_bounds, individual_size, max_iter, air_plot=False):
        super().__init__(objfunc)
        self.max_iter = max_iter

        # 定义个体 / 种群
        self.individual = GAIndividual(ranges=var_bounds, encoding='binary', eps=0.001)
        self.population = GAPopulation(indv_template=self.individual, size=individual_size).init()

        # Create genetic operators.
        # selection = RouletteWheelSelection()
        selection = TournamentSelection()  
        crossover = UniformCrossover(pc=0.8, pe=0.5)   
        mutation = FlipBitBigMutation(pm=0.1, pbm=0.55, alpha=0.6) 

        self.engine = GAEngine(population=self.population, selection=selection,
                               crossover=crossover, mutation=mutation,
                               analysis=[FitnessStore])

        @self.engine.fitness_register
        def fitness(indv):
            """
            适应度函数： 注意这里默认为优化得到最小值
            :param indv:
            :return:
            """
            x = indv.variants
            return -objfunc(x)

        @self.engine.analysis_register
        class ConsoleOutputAnalysis(OnTheFlyAnalysis):
            interval = 1
            master_only = True

            def register_step(self, g, population, engine):
                best_indv = population.best_indv(engine.fitness)
                msg = 'Generation: {}, best fitness: {:.3f}'.format(g, engine.fitness(best_indv))
                self.logger.info(msg)

            def finalize(self, population, engine):
                best_indv = population.best_indv(engine.fitness)
                x = best_indv.variants
                y = engine.fitness(best_indv)
                msg = 'Optimal solution: ({}, {})'.format(x, y)
                self.logger.info(msg)

    def run(self):
        self.engine.run(ng=self.max_iter)

if __name__ == '__main__':
    from PyOptimize.General_Opt import Test_function

    def Rosenbrock(x):
        return Test_function().Rosenbrock(x)[0]

    GAFT_Test = pyGaft(Rosenbrock, [(-2, 2)] * 10, 26, 1000).run()

    def Rosenbrock(self, x):
        """
        高阶Rosenbrock函数
        给出最优解
            最优解仍然应在所有x为1时
        :param x:
        :return:
        """
        f = [0.0] * 1
        function_sum = 0
        for i in np.arange(0, len(x)-1):
            function_sum += (1 - x[i]) ** 2 + 100 * ((x[i + 1] - x[i] ** 2) ** 2)
        f[0] = function_sum
        return f

def func_get_runtime_decorator(func):
    """
     用于debug的函数装饰器: 测试函数的运行时间
     :param func:
     :return:
     """

    def wrapper(*args, **kw):
        print('run: %s():' % func.__name__)
        start = timeit.default_timer()
        try:
            func(*args, **kw)
        except:
            raise RuntimeError('!Error, failed executing: %s()' % func.__name__)
        finally:
            stop = timeit.default_timer()
            time_inc = stop - start
            print('func %s runtime is: %s seconds' % (func.__name__, time_inc))
            print('end run: %s():' % func.__name__)

    return wrapper