Esempio n. 1
0
def run_pygmo():
    algos = [('PyGMO_DE',algorithm.de(gen=1)),
        ('PyGMO_DE_v1',algorithm.de(gen=1,f=.2,cr=1.0,variant=4)),
        #('PyGMO_DE_v2',algorithm.de(gen=1,f=.1,cr=1.0,variant=4)),
        #('PyGMO_DE_v3',algorithm.de(gen=1,f=.3,cr=1.0,variant=4)),
        #('PyGMO_DE_v4',algorithm.de(gen=1,f=.2,cr=0.9,variant=4)),
        ('PyGMO_JDE',algorithm.jde(gen=1)),
        ('PyGMO_MDE_PBX',algorithm.mde_pbx(gen=1)),
        ('PyGMO_PSO',algorithm.pso(gen=1,variant=5)),
        ('PyGMO_PSO_GEN',algorithm.pso_gen(gen=1)),
        ('PyGMO_BEE_COLONY',algorithm.bee_colony(gen=1)),        
        ('PyGMO_IHS',algorithm.ihs(iter=pop_size))]
        
    run_eval("PyGMO",algos)
Esempio n. 2
0
def run_test(n_trials=200, pop_size = 20, n_gen = 500):

    number_of_trials = n_trials
    number_of_individuals = pop_size
    number_of_generations = n_gen
    
    prob_list = [problem.schwefel(dim = 10),
        problem.michalewicz(dim = 10),
        problem.rastrigin(dim = 10),
        problem.rosenbrock(dim = 10),
        problem.ackley(dim = 10),
        problem.griewank(dim = 10)]

    if __extensions__['gtop']:
        prob_list.append(problem.cassini_1())
        prob_list.append(problem.cassini_2())
        prob_list.append(problem.gtoc_1())
        prob_list.append(problem.rosetta())
        prob_list.append(problem.messenger_full())
        prob_list.append(problem.tandem(prob_id = 6, max_tof = 10))

    algo_list = [algorithm.pso(gen = number_of_generations),
                 algorithm.de(gen = number_of_generations,xtol=1e-30, ftol=1e-30),
                 algorithm.jde(gen = number_of_generations, variant_adptv=2,xtol=1e-30, ftol=1e-30),
                 algorithm.de_1220(gen = number_of_generations, variant_adptv=2,xtol=1e-30, ftol=1e-30),
                 algorithm.sa_corana(iter = number_of_generations*number_of_individuals,Ts = 1,Tf = 0.01),
                 algorithm.ihs(iter = number_of_generations*number_of_individuals),
                 algorithm.sga(gen = number_of_generations),
                 algorithm.cmaes(gen = number_of_generations,xtol=1e-30, ftol=1e-30),
                 algorithm.bee_colony(gen = number_of_generations/2)]
                 
    print('\nTrials: ' + str(n_trials) + ' - Population size: ' + str(pop_size) + ' - Generations: ' + str(n_gen))
    for prob in prob_list:
        print('\nTesting problem: ' + prob.get_name() + ', Dimension: ' + str(prob.dimension) )
        print('With Population Size: ' +  str(pop_size) )
        for algo in algo_list:
            print(' ' + str(algo))
            best = []
            best_x = []
            for i in range(0,number_of_trials):
                isl = island(algo,prob,number_of_individuals)
                isl.evolve(1)
                isl.join()
                best.append(isl.population.champion.f)
                best_x.append(isl.population.champion.x)
            print(' Best:\t' + str(min(best)[0]))
            print(' Mean:\t' + str(mean(best)))
            print(' Std:\t' + str(std(best)))
Esempio n. 3
0
def run(n_tri,n_gen,pop_size):
    import numpy
    
    #inital number of generations
    number_of_generations = 1
    number_of_trials = n_tri
    number_of_individuals = pop_size
    
    algo_list = [algorithm.pso(gen = number_of_generations),
                 algorithm.de(gen = number_of_generations,xtol=1e-30, ftol=1e-30),
                 algorithm.jde(gen = number_of_generations, variant_adptv=2,xtol=1e-30, ftol=1e-30),
                 algorithm.de_1220(gen = number_of_generations, variant_adptv=2,xtol=1e-30, ftol=1e-30),
                 #algorithm.sa_corana(iter = number_of_generations*number_of_individuals,Ts = 1,Tf = 0.01),
                 algorithm.ihs(iter = number_of_generations*number_of_individuals),
                 #algorithm.sga(gen = number_of_generations),
                 algorithm.cmaes(gen = number_of_generations,xtol=1e-30, ftol=1e-30),
                 algorithm.bee_colony(gen = number_of_generations)
    ]
                 
    
    algo_means_list = []
    algo_name_list = []
    print('\nTrials: ' + str(n_tri) + ' - Population size: ' + str(pop_size) + ' - Generations: ' + str(n_gen))
    for algo in algo_list:
            print(' ' + str(algo))
            algo_name_list.append(algo.get_name())
            
            trials = []
            trials_max_len = 0
            for i in range(number_of_trials):
                print ".",
                trials.append(single_test(algo,total_evals,pop_size))

            t_minlen = min([len(t) for t in trials])
            t_new = numpy.array([t[:t_minlen-1] for t in trials ])
            t_new = numpy.mean(t_new,axis=0)
            algo_means_list.append(t_new[:,1])
    
    plot_multi(algo_means_list,names=algo_name_list,trials=number_of_trials)
Esempio n. 4
0
def run_test(n_trials=200, pop_size=20, n_gen=500):
    """
    This function runs some tests on the algorthm. Use it to verify the correct installation
    of PyGMO.

    USAGE: PyGMO.run_test(n_trials=200, pop_size = 20, n_gen = 500)

    * n_trials: each algorithm will be called n_trials times on the same problem to then evaluate best, mean and std
    * pop_size: this determines the population size
    * n_gen: this regulates the maximim number of function evaluation

    """
    from PyGMO import problem, algorithm, island
    from numpy import mean, std
    number_of_trials = n_trials
    number_of_individuals = pop_size
    number_of_generations = n_gen

    prob_list = [
        problem.schwefel(
            dim=10), problem.rastrigin(
            dim=10), problem.rosenbrock(
            dim=10), problem.ackley(
            dim=10), problem.griewank(
            dim=10), problem.levy5(10)]
    if __extensions__['gtop']:
        prob_list.append(problem.cassini_1())
        prob_list.append(problem.gtoc_1())
        prob_list.append(problem.cassini_2())
        prob_list.append(problem.messenger_full())

    algo_list = [
        algorithm.pso(
            gen=number_of_generations),
        algorithm.mde_pbx(
            gen=number_of_generations,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.de(
            gen=number_of_generations,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.jde(
            gen=number_of_generations,
            memory=False,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.de_1220(
            gen=number_of_generations,
            memory=False,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.sa_corana(
            iter=number_of_generations *
            number_of_individuals,
            Ts=1,
            Tf=0.01),
        algorithm.ihs(
            iter=number_of_generations *
            number_of_individuals),
        algorithm.sga(
            gen=number_of_generations),
        algorithm.cmaes(
            gen=number_of_generations,
            xtol=1e-30,
            ftol=1e-30,
            memory=False),
        algorithm.bee_colony(
            gen=number_of_generations /
            2)]
    print('\nTrials: ' + str(n_trials) + ' - Population size: ' +
          str(pop_size) + ' - Generations: ' + str(n_gen))
    for prob in prob_list:
        print('\nTesting problem: ' + prob.get_name() +
              ', Dimension: ' + str(prob.dimension))
        print('With Population Size: ' + str(pop_size))
        for algo in algo_list:
            print(' ' + str(algo))
            best = []
            best_x = []
            for i in range(0, number_of_trials):
                isl = island(algo, prob, number_of_individuals)
                isl.evolve(1)
                isl.join()
                best.append(isl.population.champion.f)
                best_x.append(isl.population.champion.x)
            print(' Best:\t' + str(min(best)[0]))
            print(' Mean:\t' + str(mean(best)))
            print(' Std:\t' + str(std(best)))
Esempio n. 5
0
def run_test(n_trials=200, pop_size=20, n_gen=500):
    """
    This function runs some tests on the algorthm. Use it to verify the correct installation
    of PyGMO.

    USAGE: PyGMO.run_test(n_trials=200, pop_size = 20, n_gen = 500)

    * n_trials: each algorithm will be called n_trials times on the same problem to then evaluate best, mean and std
    * pop_size: this determines the population size
    * n_gen: this regulates the maximim number of function evaluation

    """
    from PyGMO import problem, algorithm, island
    from numpy import mean, std
    number_of_trials = n_trials
    number_of_individuals = pop_size
    number_of_generations = n_gen

    prob_list = [
        problem.schwefel(
            dim=10), problem.rastrigin(
            dim=10), problem.rosenbrock(
            dim=10), problem.ackley(
            dim=10), problem.griewank(
            dim=10), problem.levy5(10)]
    if __extensions__['gtop']:
        prob_list.append(problem.cassini_1())
        prob_list.append(problem.gtoc_1())
        prob_list.append(problem.cassini_2())
        prob_list.append(problem.messenger_full())

    algo_list = [
        algorithm.pso(
            gen=number_of_generations),
        algorithm.mde_pbx(
            gen=number_of_generations,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.de(
            gen=number_of_generations,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.jde(
            gen=number_of_generations,
            memory=False,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.de_1220(
            gen=number_of_generations,
            memory=False,
            xtol=1e-30,
            ftol=1e-30),
        algorithm.sa_corana(
            iter=number_of_generations *
            number_of_individuals,
            Ts=1,
            Tf=0.01),
        algorithm.ihs(
            iter=number_of_generations *
            number_of_individuals),
        algorithm.sga(
            gen=number_of_generations),
        algorithm.cmaes(
            gen=number_of_generations,
            xtol=1e-30,
            ftol=1e-30,
            memory=False),
        algorithm.bee_colony(
            gen=number_of_generations /
            2)]
    print('\nTrials: ' + str(n_trials) + ' - Population size: ' +
          str(pop_size) + ' - Generations: ' + str(n_gen))
    for prob in prob_list:
        print('\nTesting problem: ' + prob.get_name() +
              ', Dimension: ' + str(prob.dimension))
        print('With Population Size: ' + str(pop_size))
        for algo in algo_list:
            print(' ' + str(algo))
            best = []
            best_x = []
            for i in range(0, number_of_trials):
                isl = island(algo, prob, number_of_individuals)
                isl.evolve(1)
                isl.join()
                best.append(isl.population.champion.f)
                best_x.append(isl.population.champion.x)
            print(' Best:\t' + str(min(best)[0]))
            print(' Mean:\t' + str(mean(best)))
            print(' Std:\t' + str(std(best)))