Multi-Population Run

Multi-Population Run#

  1. Run multi-popultion with multiple optimizer, using the Optimizer.detach function:

    • Firstly, we initialize like in Quick Start:

     1import random, HyperGP
 2from HyperGP import Population, PrimitiveSet, executor, Tensor, GpOptimizer
 3from HyperGP.library.operators import RandTrCrv, RandTrMut
 4from HyperGP.states import ProgBuildStates, ParaStates
 5
 6# Generate training set
 7input_array = Tensor.uniform(0, 10, size=(2, 10000))
 8target = HyperGP.exp((input_array[0] + 1) ** 2) / (input_array[1] + input_array[0])
 9
10# Generate primitive set
11pset = PrimitiveSet(input_arity=1,  primitive_set=[('add', HyperGP.add, 2),('sub', HyperGP.sub, 2),('mul', HyperGP.mul, 2),('div', HyperGP.div, 2)])
12
13# Init workflow
14optimizer = GpOptimizer()
15
16# Add components
17# Add components
18optimizer.iter_component(
19    ParaStates(func=RandTrCrv(), source=["p_list", "p_list"], to=["p_list", "p_list"],
20                mask=[list(random.sample(range(100), 50)), list(random.sample(range(100), 50))]),
21    ParaStates(func=RandTrMut(), source=["p_list", ProgBuildStates(pset=pset, depth_rg=[2, 3], len_limit=10000), True], to=["p_list"],
22                mask=[random.sample(range(100), 100), 1, 1]),
23    ParaStates(func=ExecGPU(), source=["p_list", "input", "pset"], to=["output", None],
24                mask=[1, 1, 1]),
25    ParaStates(func=evaluation, source=["output", "target"], to=["fit_list"],
26                mask=[1, 1]))

    • Here, we initialize multiple population:

     1pop_num = 5
 2
 3optimizers = [optimizer]
 4# Init population
 5pop = [
 6    Population(pop_size=100, prog_paras=ProgBuildStates(pset=pset, depth_rg=[2, 3], len_limit=10000), parallel=False)
 7    for i in range(pop_num)
 8]
 9
10optimizers.append([optimizer.detach() for i in range(pop_num - 1)])
11
12# Register relevant states
13for i in range(pop_num):
14    optimizers[i].status_init(
15        p_list=pop[i].states['progs'].indivs,
16        input=input_array,pset=pset,output=None,
17        fit_list = pop[i].states['progs'].fitness)

    • Run multiple optimizers:

    1for i in range(pop_num):
2    optimizers[i].run(20)
3    fit_best = optimizers[i].fit_list[HyperGP.argsort(optimizers[i].fit_list)[0]]
4    print('fit_best: ', fit_best)
  2. Run multi-population within a single optimizer:

    We can also run the multiple population within a single optimizer, using the mask set:

    • add component:

     1def set_mask(pop_num, per_size):
 2    cdds_1, cdds_2 = [], []
 3    for i in pop_num:
 4        cdds_1 += random.sample(range(per_size * i, per_size * (i + 1)), per_size / 2)
 5        cdds_2 += random.sample(range(per_size * i, per_size * (i + 1)), per_size / 2)
 6    return [cdds_1, cdds_2]
 7
 8# Add components
 9optimizer.iter_component(
10    ParaStates(func=RandTrCrv(), source=["multip_list", "multip_list"], to=["multip_list", "multip_list"],
11                mask=set_mask(5, 100)),
12    ParaStates(func=RandTrMut(), source=["multip_list", ProgBuildStates(pset=pset, depth_rg=[2, 3], len_limit=10000), True], to=["multip_list"],
13                mask=[random.sample(range(100), 100), 1, 1]),
14    ParaStates(func=ExecGPU(), source=["multip_list", "input", "pset"], to=["output", None],
15                mask=[1, 1, 1]),
16    ParaStates(func=evaluation, source=["output", "target"], to=["fit_list"],
17                mask=[1, 1]))

    • Intialize the optimizer:

     1pop_num = 5
 2
 3# Init population
 4pop = Population(pop_size=500, prog_paras=ProgBuildStates(pset=pset, depth_rg=[2, 3], len_limit=10000), parallel=False)
 5
 6# Register relevant states
 7optimizer.status_init(
 8    multip_list=pop.states['progs'].indivs,
 9    input=input_array,pset=pset,output=None,
10    fit_list = pop.states['progs'].fitness)

    • Run the optimizer:

    1optimizers.run(20)
2fit_best = [optimizers.fit_list[HyperGP.argsort(optimizers.fit_list[100 * i:100 *(i+1)])[0]] for i in range(pop_num)]
3print('fit_best: ', fit_best)