def evaluate(self, hive_nectar, majority, guidance): if hive_nectar > 10: adjusted_nectar = 1 elif hive_nectar < 0: adjusted_nectar = 0 else: adjusted_nectar = hive_nectar / 10 brain = nn.create_phenotype(self.chromo) # implementing the ability for bees to be 'guided' if guidance: found_nectar = guidance else: found_nectar = random.random() ################################################# ins = (found_nectar, self.outputs[-1][0], self.fitnesses[-1], hive_nectar, majority) #self.inputs[-1][0]) brain.flush() outs = brain.pactivate(ins) self.inputs.append(ins) self.outputs.append(outs)
def eval_individual(chromo): brain = nn.create_phenotype(chromo) found_nectar = random.random() brain.flush() output = brain.sactivate([found_nectar]) return (found_nectar, output[0])
def eval_individual(chromo, last_choice, last_fitness, hive_nectar): brain = nn.create_phenotype(chromo) found_nectar = random.random() brain.flush() output = brain.sactivate([found_nectar, last_choice, last_fitness, hive_nectar]) exp.write(str(output[0])+'\n') return (found_nectar, output[0])
def evalFitness(self,genomes): print("evalFitness") for g in genomes: net = nn.create_phenotype(g) #net = nn.create_fast_feedforward_phenotype(g) g.fitness = self.run(net) print(g.fitness) """
def evaluate_population(population): twelve_degrees = 0.2094384 #radians num_steps = 10**5 for chromo in population: net = nn.create_phenotype(chromo) # initial conditions (as used by Stanley) x = random.randint(0, 4799) / 1000.0 - 2.4 x_dot = random.randint(0, 1999) / 1000.0 - 1.0 theta = random.randint(0, 399) / 1000.0 - 0.2 theta_dot = random.randint(0, 2999) / 1000.0 - 1.5 #x = 0.0 #x_dot = 0.0 #theta = 0.0 #theta_dot = 0.0 fitness = 0 for trials in xrange(num_steps): # maps into [0,1] inputs = [(x + 2.4) / 4.8, (x_dot + 0.75) / 1.5, (theta + twelve_degrees) / 0.41, (theta_dot + 1.0) / 2.0] # a normalizacao so acontece para estas condicoes iniciais # nada garante que a evolucao do sistema leve a outros # valores de x, x_dot e etc... action = net.pactivate(inputs) #print inputs,action # [0.6731124662078692, 0.4177235725492288, 0.34882554840901664, 0.41364238610962345] [0.344597476333986] # Apply action to the simulated cart-pole x, x_dot, theta, theta_dot = cart_pole(action[0], x, x_dot, theta, theta_dot) # Check for failure. If so, return steps # the number of steps indicates the fitness: higher = better fitness += 1 if (abs(x) >= 2.4 or abs(theta) >= twelve_degrees): #if abs(theta) > twelve_degrees: # Igel (p. 5) uses theta criteria only # the cart/pole has run/inclined out of the limits break chromo.fitness = fitness
def evaluate(self, hive_nectar): if hive_nectar > 10: adjusted_nectar = 1 elif hive_nectar < 0: adjusted_nectar = 0 else: adjusted_nectar = hive_nectar / 10 # adjusted_nectar = brain = nn.create_phenotype(self.chromo) found_nectar = random.random() ins = (found_nectar, self.outputs[-1][0], self.fitnesses[-1], hive_nectar) brain.flush() outs = brain.pactivate(ins) self.inputs.append(ins) self.outputs.append(outs)
def evaluate_population(chromosomes): num_steps = 10 ** 5 for chromo in chromosomes: net = nn.create_phenotype(chromo) # initial conditions (as used by Stanley) x = random.randint(0, 4799) / 1000.0 - 2.4 x_dot = random.randint(0, 1999) / 1000.0 - 1.0 theta = random.randint(0, 399) / 1000.0 - 0.2 theta_dot = random.randint(0, 2999) / 1000.0 - 1.5 fitness = 0 for trials in xrange(num_steps): # maps into [0,1] inputs = [(x + 2.4) / 4.8, (x_dot + 0.75) / 1.5, (theta + angle_limit) / 0.41, (theta_dot + 1.0) / 2.0] action = net.pactivate(inputs) action[0] += 0.4 * (random.random() - 0.5) # Apply action to the simulated cart-pole x, x_dot, theta, theta_dot = cart_pole(action[0], x, x_dot, theta, theta_dot) # Check for failure. If so, return steps # the number of steps indicates the fitness: higher = better fitness += 1 if abs(x) >= 2.4 or abs(theta) >= angle_limit: # if abs(theta) > angle_limit: # Igel (p. 5) uses theta criteria only # the cart/pole has run/inclined out of the limits break chromo.fitness = fitness
cart = gz.rectangle(SCALE * 0.5, SCALE * 0.25, xy=(150, 80), stroke_width=1, fill=(0, 1, 0)) pole = gz.rectangle(SCALE * 0.1, SCALE * 1.0, xy=(150, 55), stroke_width=1, fill=(1, 1, 0)) # random.seed(0) # load the winner with open('winner_chromosome') as f: c = cPickle.load(f) print 'Loaded chromosome:' print c local_dir = os.path.dirname(__file__) config = Config(os.path.join(local_dir, 'spole_config')) net = nn.create_phenotype(c) # initial conditions (as used by Stanley) x = randint(0, 4800) / 1000.0 - 2.4 x_dot = randint(0, 4000) / 1000.0 - 2.0 theta = randint(0, 400) / 1000.0 - 0.2 theta_dot = randint(0, 3000) / 1000.0 - 1.5 last_t = 0 def make_frame(t): global x, x_dot, theta, theta_dot, last_t # maps into [0,1] inputs = [(x + 2.4) / 4.8,
def run(self, testing=False): """ Runs the cart-pole experiment and evaluates the population. """ if self.__markov: # markov experiment: full system's information is provided to the network for chromo in self.__population: # chromosome to phenotype assert chromo.num_inputs == 6, "There must be 6 inputs to the network" net = nn.create_phenotype(chromo) self.__initial_state() if testing: # cart's position, first pole's angle, second pole's angle # print "\nInitial conditions:" print "{0:f} \t {1:f} \t {2:f}".format(self.__state[0], self.__state[2], self.__state[4]) pass steps = 0 while steps < 100000: inputs = [self.__state[0] / 4.80, # cart's initial position self.__state[1] / 2.00, # cart's initial speed self.__state[2] / 0.52, # pole_1 initial angle self.__state[3] / 2.00, # pole_1 initial angular velocity self.__state[4] / 0.52, # pole_2 initial angle self.__state[5] / 2.00] # pole_2 initial angular velocity # activate the neural network output = net.pactivate(inputs) # maps [-1,1] onto [0,1] action = 0.5 * (output[0] + 1.0) # advances one time step self.__state = integrate(action, self.__state, 1) if self.__outside_bounds(): # network failed to solve the task if testing: print "Failed at step {0:d} \t {1:+1.2f} \t {2:+1.2f} \t {3:+1.2f}".format(steps, self.__state[0], self.__state[2], self.__state[4]) sys.exit(0) else: break steps += 1 chromo.fitness = float(steps) # the higher the better # if self.print_status: # print "Chromosome %3d evaluated with score: %d " %(chromo.id, chromo.fitness) else: # non-markovian: no velocity information is provided (only 3 inputs) for chromo in self.__population: assert chromo.num_inputs == 3, "There must be 3 inputs to the network" net = nn.create_phenotype(chromo) self.__initial_state() chromo.fitness, score = self.__non_markov(net, 1000, testing) # print "Chromosome %3d %s evaluated with fitness %2.5f and score: %s" %(chromo.id, chromo.size(), chromo.fitness, score) # we need to make sure that the found solution is robust enough and good at # generalizing for several different initial conditions, so the champion # from each generation (i.e., the one with the highest F) passes for a # generalization test (the criteria here was defined by Gruau) best = max(self.__population) # selects the best network if self.print_status: print "\t\nBest chromosome of generation: {0:d}".format(best.ID) # ** *******************# # GENERALIZATION TEST # # **********************# # first: can it balance for at least 100k steps? best_net = nn.create_phenotype(best) best_net.flush() self.__initial_state() # reset initial state # long non-markovian test if self.print_status: print "Starting the 100k test..." score = self.__non_markov(best_net, 100000, testing)[1] if score > 99999: if self.print_status: print "\tWinner passed the 100k test! Starting the generalization test..." # second: now let's try 625 different initial conditions balanced = self.__generalization_test(best_net, testing) if balanced > 200: if self.print_status: print "\tWinner passed the generalization test with score: {0:d}\n".format(balanced) # set chromosome's fitness to 100k (and ceases the simulation) best.fitness = 100000 best.score = balanced else: if self.print_status: print "\tWinner failed the generalization test with score: {0:d}\n".format(balanced) else: if self.print_status: print "\tWinner failed at the 100k test with score {0:d}\n ".format(score)
def run(self, testing=False): """ Runs the cart-pole experiment and evaluates the population. """ if self.__markov: # markov experiment: full system's information is provided to the network for chromo in self.__population: # chromosome to phenotype assert chromo.num_inputs == 6, "There must be 6 inputs to the network" net = nn.create_phenotype(chromo) self.__initial_state() if testing: # cart's position, first pole's angle, second pole's angle # print "\nInitial conditions:" print "{0:f} \t {1:f} \t {2:f}".format( self.__state[0], self.__state[2], self.__state[4]) pass steps = 0 while steps < 100000: inputs = [ self.__state[0] / 4.80, # cart's initial position self.__state[1] / 2.00, # cart's initial speed self.__state[2] / 0.52, # pole_1 initial angle self.__state[3] / 2.00, # pole_1 initial angular velocity self.__state[4] / 0.52, # pole_2 initial angle self.__state[5] / 2.00 ] # pole_2 initial angular velocity # activate the neural network output = net.pactivate(inputs) # maps [-1,1] onto [0,1] action = 0.5 * (output[0] + 1.0) # advances one time step self.__state = integrate(action, self.__state, 1) if self.__outside_bounds(): # network failed to solve the task if testing: print "Failed at step {0:d} \t {1:+1.2f} \t {2:+1.2f} \t {3:+1.2f}".format( steps, self.__state[0], self.__state[2], self.__state[4]) sys.exit(0) else: break steps += 1 chromo.fitness = float(steps) # the higher the better # if self.print_status: # print "Chromosome %3d evaluated with score: %d " %(chromo.id, chromo.fitness) else: # non-markovian: no velocity information is provided (only 3 inputs) for chromo in self.__population: assert chromo.num_inputs == 3, "There must be 3 inputs to the network" net = nn.create_phenotype(chromo) self.__initial_state() chromo.fitness, score = self.__non_markov(net, 1000, testing) # print "Chromosome %3d %s evaluated with fitness %2.5f and score: %s" %(chromo.id, chromo.size(), chromo.fitness, score) # we need to make sure that the found solution is robust enough and good at # generalizing for several different initial conditions, so the champion # from each generation (i.e., the one with the highest F) passes for a # generalization test (the criteria here was defined by Gruau) best = max(self.__population) # selects the best network if self.print_status: print "\t\nBest chromosome of generation: {0:d}".format( best.ID) # ** *******************# # GENERALIZATION TEST # # **********************# # first: can it balance for at least 100k steps? best_net = nn.create_phenotype(best) best_net.flush() self.__initial_state() # reset initial state # long non-markovian test if self.print_status: print "Starting the 100k test..." score = self.__non_markov(best_net, 100000, testing)[1] if score > 99999: if self.print_status: print "\tWinner passed the 100k test! Starting the generalization test..." # second: now let's try 625 different initial conditions balanced = self.__generalization_test(best_net, testing) if balanced > 200: if self.print_status: print "\tWinner passed the generalization test with score: {0:d}\n".format( balanced) # set chromosome's fitness to 100k (and ceases the simulation) best.fitness = 100000 best.score = balanced else: if self.print_status: print "\tWinner failed the generalization test with score: {0:d}\n".format( balanced) else: if self.print_status: print "\tWinner failed at the 100k test with score {0:d}\n ".format( score)
from random import randint import cPickle as pickle import single_pole chromosome.node_gene_type = genome2.NodeGene # load the winner file = open('winner_chromosome', 'r') c = pickle.load(file) file.close() print 'Loaded chromosome:' print c config.load('spole_config') net = nn.create_phenotype(c) #x = 0.0 #x_dot = 0.0 #theta = 0.0 #theta_dot = 0.0 # initial conditions (as used by Stanley) x = randint(0, 4799) / 1000.0 - 2.4 x_dot = randint(0, 1999) / 1000.0 - 1.0 theta = randint(0, 399) / 1000.0 - 0.2 theta_dot = randint(0, 2999) / 1000.0 - 1.5 print "\nInitial conditions:" print "%2.4f %2.4f %2.4f %2.4f" % (x, x_dot, theta, theta_dot) for step in xrange(10**5):
def eval_individual(chromo,logFP=None): brain = nn.create_phenotype(chromo) sumTime = 0 sumPeople = 0 sumDist = 0 for trial in range(3): window = GraphWin("CS81 Final Project",1000,1000) window.setBackground("blue") preyList = [] time = 0 people = 0 distance = 0 p1 = Prey(0,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p2 = Prey(1,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p3 = Prey(2,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p4 = Prey(3,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p5 = Prey(4,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p6 = Prey(5,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p7 = Prey(6,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p8 = Prey(7,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p9 = Prey(8,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p10 = Prey(9,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p11 = Prey(10,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p12 = Prey(11,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p13 = Prey(12,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p14 = Prey(13,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p15 = Prey(14,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p16 = Prey(15,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p17 = Prey(16,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p18 = Prey(17,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p19 = Prey(18,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) p20 = Prey(19,(random()*800) + 100,(random()*800) + 100,choice([-1,1])*2*pi*random(),window) preyList.append(p1) preyList.append(p2) preyList.append(p3) preyList.append(p4) preyList.append(p5) preyList.append(p6) preyList.append(p7) preyList.append(p8) preyList.append(p9) preyList.append(p10) preyList.append(p11) preyList.append(p12) preyList.append(p13) preyList.append(p14) preyList.append(p15) preyList.append(p16) preyList.append(p17) preyList.append(p18) preyList.append(p19) preyList.append(p20) shark = Predator(1000,1000,5*pi/4,window) while (len(preyList) > 3) and time < 15000: time += 1 for p in preyList: if time %50 == 0: distance += p.getTraveled() p.setPastX(p.getX()) p.setPastY(p.getY()) brain.flush() inputs = p.calculateInputs(preyList,shark) if inputs == "DEAD": preyList.remove(p) else: outputs = brain.pactivate(inputs) p.move(outputs[0],outputs[1]) if time == 4500: print "Shark attack!" if time > 4500: shark.move(preyList) window.close() people = len(preyList) time -= 4500 time /= float(10500) people /= float(20) distance /= float(75000) sumTime += time sumPeople += people sumDist += distance return .4*(sumTime/3) + .4*(sumPeople/3) + .2*(sumDist/3)