def justsim(ind, swarm, targets, timesteps, trials=100): # Decode genome into executable behaviour tree bt = tg.tree().decode(ind, swarm, targets) bt.setup(timeout=15) fits = [] dur = 0 score = 0 for k in range(trials): fitness = 0 score = 0 t = 0 found = False bt = tg.tree().decode(ind, swarm, targets) swarm.beacon_set = [] while t <= timesteps and found == False: t += 1 bt.tick() swarm.iterate() swarm.get_state() score = targets.get_state(swarm, t) if targets.found == len(targets.targets): found = True maxsize = 300 fitness = 0 fitness = score / len(targets.targets) fitness = fitness - (len(ind.genome) / 1000000) if fitness < 0: fitness = 0 print('fitness: ', fitness) targets.reset() swarm.reset() maxsize = 300 fitness = 0 fitness = score / (trials * len(targets.targets)) fitness = fitness - (len(ind.genome) * 0.001) if fitness < 0: fitness = 0 print('Average fitness: ', fitness) print(ind.tree) return fits
def extinction(population, deathrate, indsize, blackboard): # Kill off proportion of population and replace with new individuals for n in range(len(population)): if random.uniform(0,1) <= deathrate: # kill individual and replace with new population[n] = tg.individual(tg.tree().make_tree(indsize, blackboard)) return population
def parallel(ind, swarm, targets, timesteps): bt = tg.tree().decode(ind, swarm, targets) tg.tree().ascii_tree(ind) # Set the number of trials per individual to determine fitness trials = 1 dur = 0 score = 0 for k in range(trials): fitness = 0 t = 0 # RUN SIMULATION!!! ############################################ found = False # IMPORTANT! need to reset behaviours after each run swarm.beacon_set = [] bt = tg.tree().decode(ind, swarm, targets) while t <= timesteps and found == False: t += 1 bt.tick() swarm.iterate() swarm.get_state() score += targets.get_state(swarm, t) if targets.found == len(targets.targets): found = True targets.reset() swarm.reset() maxsize = 300 fitness = 0 fitness = score/(trials*len(targets.targets)) fitness = fitness - (len(ind.genome)*0.001) if fitness < 0: fitness = 0 ind.fitness = fitness return ind
def serial(pop, oldswarm, boxes, genum, timesteps, treecost, field, grid): # Evaluate fitness of each individual in population for z in range(0, len(pop)): swarm = bsim.swarm() swarm.size = oldswarm.size swarm.behaviour = 'none' swarm.speed = 0.5 swarm.origin = oldswarm.origin swarm.gen_agents() env = bsim.map() ''' The map has to be set to the same as passed into the evolution!!! ''' #swarm = oldswarm.copy() # Decode genome into executable behaviour tree print( 'Evaluating Individual: ', z, ' Gen: ', genum) bt = tg.tree().decode(pop[z], swarm, boxes) tg.tree().ascii_tree(pop[z]) # Set the number of trials per individual to determine fitness trials = 1; dur = 0 score = 0 ; totscore = 0 record = np.zeros(trials) for k in range(trials): swarm = bsim.swarm() swarm.size = oldswarm.size swarm.behaviour = 'none' swarm.speed = 0.5 swarm.gen_agents() swarm.grid = grid swarm.field = field env = bsim.map() ''' The map has to be set to the same as passed into the evolution!!! ''' env.bounded = True env.env1() env.gen() swarm.map = env boxes = bsim.boxes() boxes.set_state('state1') boxes.sequence = False boxes.radius = 3 fitness = 0 t = 0 found = False # IMPORTANT! need to reset behaviours after each run swarm.beacon_set = [] bt = tg.tree().decode(pop[z], swarm, boxes) noise = np.random.uniform(-.1,.1,(timesteps, swarm.size, 2)) # Reset score score = 0 while t <= timesteps and found == False: bt.tick() swarm.iterate(noise[t-1]) swarm.get_state() score = boxes.get_state(swarm,t) t += 1 #score = boxes.tot_collected print('score = ' , score) boxes.reset() swarm.reset() print ('-------------------------------------------------------------------') maxsize = 300 fitness = 0 fitness = score/(len(boxes.boxes)) fitness = fitness - (len(pop[z].genome)*treecost) if fitness < 0: fitness = 0 print ('Individual fitness: %.3f'% fitness) pop[z].fitness = fitness print ('=================================================================================')
extinction_prob = -1 deathrate = 0.9 hall = [] hallsize = 20 newind = 0 elitesize = 6 treecost = 0.001 op_prob = 0.25 selectionNum = popsize - elitesize - newind # Generate starting population pop = [] generations = [] * NGEN pop = [ tg.individual(tg.tree().make_tree(indsize, blackboard)) for t in range(popsize) ] # Logging variables logfit = [] logpop = [] logavg = [] logmax = [] stats = { "avgsize": [], "stdsize": [], "meanfit": [], "stdfit": [], "maxfit": [] }
def serial1(pop, swarm, targets, genum, timesteps, treecost): # Evaluate fitness of each individual in population for z in range(0, len(pop)): swarmsize = 3 swarm = asim.swarm() swarm.size = swarmsize swarm.behaviour = 'none' swarm.speed = 0.5 swarm.origin = np.array([0, 0]) swarm.gen_agents() # swarm = swarm.copy() # swarm.gen_agents() env = asim.map() env.exercise1() env.gen() swarm.map = env # Decode genome into executable behaviour tree print( 'Evaluating Individual: ', z, ' Gen: ', genum) bt = tg.tree().decode(pop[z], swarm, targets) tg.tree().ascii_tree(pop[z]) # Set the number of trials per individual to determine fitness trials = 1; dur = 0 score = 0 ; totscore = 0 for k in range(trials): fitness = 0 t = 0 found = False # IMPORTANT! need to reset behaviours after each run swarm.beacon_set = [] bt = tg.tree().decode(pop[z], swarm, targets) while t <= timesteps and found == False: t += 1 bt.tick() swarm.iterate() swarm.get_state() score = targets.get_state(swarm, t) if targets.found == len(targets.targets): found = True totscore += score targets.reset() swarm.reset() print ('-------------------------------------------------------------------') maxsize = 300 fitness = 0 fitness = totscore/(trials*len(targets.targets)) fitness = fitness - (len(pop[z].genome)*treecost) if fitness < 0: fitness = 0 print ('Individual fitness: ', fitness) pop[z].fitness = fitness print ('=================================================================================')
def adveserial(popa, popb, swarma, swarmb, targets, genum, timesteps): # Two supervisors competing against each other for coverage for z in range(0, len(popa)): # Decode genome into executable behaviour tree print( 'Evaluating Individual: ', z, ' Gen: ', genum) bta = tg.tree().decode(popa[z], swarma, targets) tg.tree().ascii_tree(popa[z]) btb = tg.tree().decode(popb[z], swarmb, targets) tg.tree().ascii_tree(popb[z]) # Set the number of trials per individual to determine fitness trials = 1; dur = 0 scorea = 0 ; scoreb = 0; totscore = 0 for k in range(trials): fitness = 0 t = 0 found = False # IMPORTANT! need to reset behaviours after each run bta = tg.tree().decode(popa[z], swarma, targets) btb = tg.tree().decode(popb[z], swarmb, targets) while t <= timesteps and found == False: t += 1 bta.tick() btb.tick() swarma.iterate() swarma.get_state() swarmb.iterate() swarmb.get_state() scorea += targets.ad_state(swarma, t) scoreb += targets.ad_state(swarmb, t) if targets.found == len(targets.targets): found = True #totscore += score targets.reset() swarma.reset() swarmb.reset() print ('-------------------------------------------------------------------') maxsize = 300 fitness = 0 fitness = scorea/(trials*len(targets.targets)) fitness = fitness - (len(popa[z].genome)/1000000) if fitness < 0: fitness = 0 popa[z].fitness = fitness print ('Individual fitness A: ', fitness) popb[z].fitness = fitness print ('=================================================================================') fitness = 0 fitness = scoreb/(trials*len(targets.targets)) fitness = fitness - (len(popb[z].genome)/1000000) if fitness < 0: fitness = 0 print ('Individual fitness B: ', fitness) popb[z].fitness = fitness print ('=================================================================================')
def default(ind, swarm, targets, timesteps): # Decode genome into executable behaviour tree bt = tg.tree().decode(ind, swarm, targets) bt.setup(timeout=15) # Setup post tick handlers for tree animation snapshot_visitor = py_trees.visitors.SnapshotVisitor() bt.add_post_tick_handler( functools.partial(post_tick_handler, snapshot_visitor)) bt.visitors.append(snapshot_visitor) # Setup plot lim = 40 xmin = -lim xmax = lim ymin = -lim ymax = lim fig, ax = plt.subplots(facecolor=(.99, .99, .99)) ax.set_xlim([xmin, xmax]) ax.set_ylim([ymin, ymax]) [ ax.plot(swarm.agents[t][0], swarm.agents[t][1], 'bo') for t in range(swarm.size) ] plt.ion() plt.grid() fig.canvas.draw() plt.show() dur = 0 score = 0 fitness = 0 t = 0 fontsize = 12 found = False swarm.beacon_set = [] while t <= timesteps and found == False: t += 1 # input() bt.tick() swarm.iterate() swarm.get_state() score = targets.get_state(swarm, t) ax.clear() ax.set_xlim([xmin, xmax]) ax.set_ylim([ymin, ymax]) plt.show() plt.grid() [ ax.plot(swarm.agents[a][0], swarm.agents[a][1], 'bo') for a in range(swarm.size) ] [ ax.plot([ swarm.map.obsticles[a].start[0], swarm.map.obsticles[a].end[0] ], [ swarm.map.obsticles[a].start[1], swarm.map.obsticles[a].end[1] ], 'k-', lw=2) for a in range(len(swarm.map.obsticles)) ] ax.text(5, 41, 'Swarm behviour: ' + swarm.behaviour + ', ' + str(swarm.param), fontsize=fontsize, color='green') ax.text(5, 45, 'Time: %d/%d' % (t, timesteps), fontsize=fontsize, color='purple') ax.text(-40, 41, 'Center of Mass: %.2f, %.2f' % (swarm.centermass[0], swarm.centermass[1]), fontsize=fontsize, color='green') ax.text(-40, 45, 'Spread: %.2f' % swarm.spread, fontsize=fontsize, color='red') ax.text(-20, 45, 'Coverage: %.2f' % targets.coverage, fontsize=fontsize, color='blue') #[ax.plot(swarm.beacon_set[a].pos[0],swarm.beacon_set[a].pos[1], 'ro', markersize=70, alpha=0.3) for a in range(len(swarm.beacon_set))] if swarm.beacon_att.size != 0: for a in range(0, len(swarm.beacon_att)): ax.plot(swarm.beacon_att[a][0], swarm.beacon_att[a][1], 'go', markersize=70, alpha=0.3) #ax.text(swarm.beacon_set[a].pos[0],swarm.beacon_set[a].pos[1], 'A', fontsize=15, color='green') if swarm.beacon_rep.size != 0: for a in range(0, len(swarm.beacon_rep)): ax.plot(swarm.beacon_rep[a][0], swarm.beacon_rep[a][1], 'ro', markersize=70, alpha=0.) #ax.text(swarm.beacon_set[a].pos[0],swarm.beacon_set[a].pos[1], 'R', fontsize=15, color='red') for n in range(0, len(targets.targets)): if targets.old_state[n] == False: ax.plot(targets.targets[n][0], targets.targets[n][1], 'ro', markersize=10, alpha=0.5) else: ax.plot(targets.targets[n][0], targets.targets[n][1], 'go', markersize=10, alpha=0.5) fig.canvas.draw() print('Time: ', t, '/', timesteps, end='\r') print('\n\nScore: ', score) print('len targets: ', len(targets.targets)) maxsize = 300 fitness = 0 fitness = score / len(targets.targets) print('fitness pre cost: ', fitness) #fitness = fitness - (len(ind.genome)*0.001) return fitness
def default_ad(inda, indb, swarma, swarmb, targets, timesteps): # Decode genome into executable behaviour tree bta = tg.tree().decode(inda, swarma, targets) bta.setup(timeout=15) btb = tg.tree().decode(indb, swarmb, targets) btb.setup(timeout=15) # Setup plot lim = 40 xmin = -lim xmax = lim ymin = -lim ymax = lim fig, ax = plt.subplots(facecolor=(.99, .99, .99)) ax.set_xlim([xmin, xmax]) ax.set_ylim([ymin, ymax]) plt.ion() plt.grid() fig.canvas.draw() plt.show() dur = 0 scorea = 0 scoreb = 0 fitness = 0 t = 0 fontsize = 12 found = False while t <= timesteps and found == False: t += 1 # input() bta.tick() btb.tick() swarma.iterate() swarma.get_state() swarmb.iterate() swarmb.get_state() scorea += targets.ad_state(swarma, t) scoreb += targets.ad_state(swarmb, t) ax.clear() ax.set_xlim([xmin, xmax]) ax.set_ylim([ymin, ymax]) plt.show() plt.grid() [ ax.plot(swarma.agents[a][0], swarma.agents[a][1], 'bo') for a in range(swarma.size) ] [ ax.plot(swarmb.agents[a][0], swarmb.agents[a][1], 'ro') for a in range(swarmb.size) ] [ ax.plot([ swarma.map.obsticles[a].start[0], swarma.map.obsticles[a].end[0] ], [ swarma.map.obsticles[a].start[1], swarma.map.obsticles[a].end[1] ], 'k-', lw=2) for a in range(len(swarma.map.obsticles)) ] ax.text(5, 41, 'Swarm behviour A: ' + swarma.behaviour + ', ' + str(swarma.param), fontsize=fontsize, color='green') ax.text(5, 45, 'Swarm behviour B: ' + swarmb.behaviour + ', ' + str(swarmb.param), fontsize=fontsize, color='green') #ax.text(-40, 41, 'Center of Mass: %.2f, %.2f' % (swarm.centermass[0], swarm.centermass[1]), fontsize=fontsize, color='green') #ax.text(-40, 45, 'Spread: %.2f' % swarm.spread, fontsize=fontsize, color='red') ax.text(-20, 45, 'Coverage: %.2f' % targets.coverage, fontsize=fontsize, color='blue') for n in range(0, len(targets.targets)): if targets.old_state[n] == False: ax.plot(targets.targets[n][0], targets.targets[n][1], 'ro', markersize=10, alpha=0.5) else: ax.plot(targets.targets[n][0], targets.targets[n][1], 'go', markersize=10, alpha=0.5) fig.canvas.draw() print('Time: ', t, '/', timesteps, end='\r') print('\n\nScore A: ', scorea) print('\nScore B: ', scoreb) print('len targets: ', len(targets.targets)) maxsize = 300 fitness = 0 fitness = score / len(targets.targets) print('fitness pre cost: ', fitness) fitness = fitness - (len(ind.genome) * 0.001) if fitness < 0: fitness = 0 print('Individual fitness: ', fitness) input() return fitness
def mutate_single(ind, mutrate, growrate, growdepth, blackboard): for b in range(0, len(ind.genome)): if random.random() <= mutrate: if random.random() <= growrate and b != 0 and b < len(ind.genome) and type(ind.genome[b]) is not Operator: # Grow a randomly generated tree subtree = tg.tree().make_tree(growdepth, blackboard) del ind.genome[b] ind.genome[b:b] = subtree[:] else: if type(ind.genome[b]) is Operator: ind.genome[b].type = random.choice(blackboard["operators"]) if type(ind.genome[b]) is Action: ind.genome[b].type = random.choice(blackboard["actions"]) if type(ind.genome[b]) is Param: choice = random.choice(['type','param']) if choice == 'type': node = tg.Param() node.generate(blackboard) ind.genome[b] = node.copy() if choice == 'param': if ind.genome[b].type == 'random': ind.genome[b].param = random.choice(blackboard["randparam"]) elif ind.genome[b].type == 'rot_anti': ind.genome[b].param = random.choice(blackboard["rotparam"]) elif ind.genome[b].type == 'rot_clock': ind.genome[b].param = random.choice(blackboard["rotparam"]) else: ind.genome[b].param = random.choice(blackboard["dirparam"]) if type(ind.genome[b]) is Env_control: choice = random.choice(['type','pos']) if choice == 'type': ind.genome[b].type = random.choice(blackboard["envcontrol"]) if choice == 'pos': ind.genome[b].pos[0] = random.choice(blackboard["envcontrol_x"]) ind.genome[b].pos[1] = random.choice(blackboard["envcontrol_y"]) if type(ind.genome[b]) is Condition: choice = random.choice(['var','value','op']) if choice == 'var': # Generate new condition node node = tg.Condition() node.generate(blackboard) ind.genome[b] = node.copy() if choice == 'op': ind.genome[b].op = random.choice(['<','>']) if choice == 'value': if ind.genome[b].var == 'density': ind.genome[b].value = random.choice(blackboard["density"]) if ind.genome[b].var == 'centery': ind.genome[b].value = random.choice(blackboard["centery"]) if ind.genome[b].var == 'centerx': ind.genome[b].value = random.choice(blackboard["centerx"]) if ind.genome[b].var == 'coverage': ind.genome[b].value = random.choice(blackboard["coverage"]) return ind
def mutate(offspring, mutrate, growrate, growdepth, blackboard): for a in range(0, len(offspring)): for b in range(0, len(offspring[a].genome)): if random.random() <= mutrate: if random.random() <= growrate and b != 0 and b < len(offspring[a].genome) and type(offspring[a].genome[b]) is not Operator: # Grow a randomly generated tree subtree = tg.tree().make_tree(growdepth, blackboard) del offspring[a].genome[b] offspring[a].genome[b:b] = subtree[:] else: if type(offspring[a].genome[b]) is Operator: offspring[a].genome[b].type = random.choice(blackboard["operators"]) if type(offspring[a].genome[b]) is Action: offspring[a].genome[b].type = random.choice(blackboard["actions"]) if type(offspring[a].genome[b]) is Param: choice = random.choice(['type','param']) if choice == 'type': # Switch behaviour to another random behaviour node = tg.Param() node.generate(blackboard) offspring[a].genome[b] = node.copy() else: if offspring[a].genome[b].type == 'random': offspring[a].genome[b].param = random.choice(blackboard["randparam"]) elif offspring[a].genome[b].type == 'rotate_clock' or offspring[a].genome[b].type == 'rotate_anti': offspring[a].genome[b].param = random.choice(blackboard["rotparam"]) else: offspring[a].genome[b].param = random.choice(blackboard["dirparam"]) if type(offspring[a].genome[b]) is Env_control: choice = random.choice(['type','pos']) if choice == 'type': offspring[a].genome[b].type = random.choice(blackboard["envcontrol"]) if choice == 'pos': offspring[a].genome[b].pos[0] = random.choice(blackboard["envcontrol_x"]) offspring[a].genome[b].pos[1] = random.choice(blackboard["envcontrol_y"]) if type(offspring[a].genome[b]) is Condition: choice = random.choice(['var','value','op']) if choice == 'var': # Generate new condition node node = tg.Condition() node.generate(blackboard) offspring[a].genome[b] = node if choice == 'op': offspring[a].genome[b].op = random.choice(['<','>']) if choice == 'value': if offspring[a].genome[b].var == 'density': offspring[a].genome[b].value = random.choice(blackboard["density"]) if offspring[a].genome[b].var == 'centery': offspring[a].genome[b].value = random.choice(blackboard["dimy"]) if offspring[a].genome[b].var == 'centerx': offspring[a].genome[b].value = random.choice(blackboard["dimx"]) if offspring[a].genome[b].var == 'agentsy': offspring[a].genome[b].value = random.choice(blackboard["dimy"]) if offspring[a].genome[b].var == 'agentsx': offspring[a].genome[b].value = random.choice(blackboard["dimx"]) if offspring[a].genome[b].var == 'mediany': offspring[a].genome[b].value = random.choice(blackboard["dimy"]) if offspring[a].genome[b].var == 'medianx': offspring[a].genome[b].value = random.choice(blackboard["dimx"]) if offspring[a].genome[b].var == 'coverage': offspring[a].genome[b].value = random.choice(blackboard["coverage"]) if offspring[a].genome[b].var == 'belief': offspring[a].genome[b].value = random.choice(blackboard["belief"]) return offspring
def mutate(offspring, mutrate, growrate, growdepth): for a in range(0, len(offspring)): for b in range(0, len(offspring[a].genome)): if random.random() <= mutrate: if random.random() <= growrate and b != 0 and b < len( offspring[a].genome) and type( offspring[a].genome[b]) is not Operator: # Grow a randomly generated tree subtree = tg.tree().make_tree(growdepth) del offspring[a].genome[b] offspring[a].genome[b:b] = subtree[:] else: if type(offspring[a].genome[b]) is Action: offspring[a].genome[b].type = random.choice([ 'disperse', 'north', 'south', 'west', 'east', 'northwest', 'southwest', 'northeast', 'northwest' ]) if type(offspring[a].genome[b]) is Param: if offspring[a].genome[b].type == 'aggregate': offspring[a].genome[b].param = random.choice( [30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80]) else: offspring[a].genome[b].param = random.choice([ 1, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60 ]) if type(offspring[a].genome[b]) is Env_control: choice = random.choice(['type', 'pos']) if choice == 'type': offspring[a].genome[b].type = random.choice( ['attract', 'repel']) if choice == 'pos': offspring[a].genome[b].pos[0] = random.choice([ -34, -32, -30, -28, -26, -24, -22, -20, -18, -16, -14, -12, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34 ]) offspring[a].genome[b].pos[1] = random.choice([ -34, -32, -30, -28, -26, -24, -22, -20, -18, -16, -14, -12, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34 ]) if type(offspring[a].genome[b]) is Condition: # offspring[a].genome[b].generate() choice = random.choice(['var', 'value', 'op']) if choice == 'var': offspring[a].genome[b].var = random.choice( ['centerx', 'centery', 'density']) if choice == 'op': offspring[a].genome[b].op = random.choice( ['<', '>']) if choice == 'value': if offspring[a].genome[b].var == 'density': offspring[a].genome[b].value = random.choice([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35 ]) if offspring[a].genome[b].var == 'centery': offspring[a].genome[b].value = random.choice([ -34, -32, -30, -28, -26, -24, -22, -20, -18, -16, -14, -12, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34 ]) if offspring[a].genome[b].var == 'centerx': offspring[a].genome[b].value = random.choice([ -34, -32, -30, -28, -26, -24, -22, -20, -18, -16, -14, -12, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34 ]) if offspring[a].genome[b].var == 'coverage': offspring[a].genome[b].value = random.choice([ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 ]) return offspring
selectionNum = popsize - elitesize # The test duration for each search attempt #Log simulation settings filename = 'exercise1' filename = 'results/exercise1' hfile = filename + '_' + 'hallfame' pop_file = filename + '_' + 'pop' op.log_settings(swarm, popsize, indsize, tournsize, elitesize, mutrate, NGEN, targets, state, timesteps, filename) # Generate starting population pop = [] generations = [] * NGEN pop = [tg.individual(tg.tree().make_tree(indsize)) for t in range(popsize)] generations.append(pop) # Logging variables logfit = [] logpop = [] logavg = [] logmax = [] # Start evolution! for i in range(0, NGEN): print('GEN: ', i) newpop = [] # Serial execution evaluate.serial1(pop, swarm, targets, i, timesteps, treecost)