def load_organism(self, name, grid, position): logger.debug("Loading '%s' from '%s'." % (name, self.__library)) name = name.lower() # Add underscore name = name.replace(" ", "_") organism_file = open("%s/%s.yaml" % (self.__library, name)) data = yaml.load(organism_file, Loader=Loader) organism_file.close() # Read defaults and use them to populate anything not specified. defaults_file = open("%s/defaults.yaml" % (self.__library)) defaults = yaml.load(defaults_file, Loader=Loader) defaults_file.close() # Incorporate the defaults into our original data. merged = _merge_trees(data, defaults) organism = Organism(grid, position) organism.set_attributes(merged) if grid.scale() < 0: # This is the first organism we added. logger.info("Setting grid scale to %f." % (organism.Scale)) grid.set_scale(organism.Scale) elif organism.Scale != grid.scale(): logger.log_and_raise(LibraryError, "Mismatch between object scale %f and grid scale %f." % \ (organism.Scale, grid.scale())) return organism
def __init__(self, ecosystem, location=None): Organism.__init__(self, ecosystem, location) self.population = 10000000 # coccolithophores fight an interminable war with viruses: self.virusWaxWane = -1 # starts waning strength virus self.virusEfficiency = 5000 # relatively weak
def __init__(self, rps, mutation_tendency = 0.3, potency = 0.5): Organism.__init__(self, mutation_tendency, potency) # calculate the new tuple indicating the chromosone's RPS strategy rps_tuple = tuple([self.post_mutation_value(mutation_tendency, i) for i in rps]) self.rps = normalize_tuple(rps_tuple)
def add_organisms(self, n): """ This function adds n organisms in random locations to the automaton where one organism is infected. """ if n < 1: return if n > self.N * self.M: raise ValueError( "\nOverpopulated environment.\nChoose different N value.") # generate n different locations. locations = set([(random.randrange(self.N), random.randrange(self.M)) for _ in range(n)]) while len(locations) < n: locations.add((random.randrange(self.N), random.randrange(self.M))) # make one infected locations = list(locations) location = random.choice(locations) locations.remove(location) self.organisms.append( Organism(location[0], location[1], states['infected'])) self.infected_count += 1 # add healthy organism for location in locations: self.organisms.append( Organism(location[0], location[1], states['healthy'])) self._update_automaton()
def test_organism(): print(style(HEADER, "---Start: Organism Class checking---")) erron = 0 o = Organism() if (hasattr(o, "dmg") & hasattr(o, "hp")) == 0: print(style(WARNING, "Your organism class doesn't initialize properly")) return if o.hp != 35: erron += 1 print( style(FAIL, "You don't initialize" " the organism's ") + style(UNDERLINE, "hp") + end_style() + style(FAIL, " to ") + style(BOLD, "35") + end_style()) if o.dmg != 10: erron += 1 print( style(FAIL, "You don't initialize" " the organism's ") + style(UNDERLINE, "dmg") + end_style() + style(FAIL, " to ") + style(BOLD, "10") + end_style()) prev_hp = o.hp o.take_damage(10) if (prev_hp - o.hp) != 10: erron += 1 print( style(FAIL, "The ") + style(UNDERLINE, "take_damage") + end_style() + style(FAIL, " method, doesn't modify the hp properly")) if erron == 0: print(style(OKGREEN, "Organism Class, perfect."))
def __init__(self, root=None, **kw): """ Creates this organism """ Organism.__init__(self, **kw) if root == None: root = self.genNode() self.tree = root
def populate(self): for i in range(self.population_size): if random.uniform(0, 1) > self.predator_chance: organism = Organism() organism.randomize() self.population.append(organism) else: predator = Predator() predator.randomize() self.population.append(predator)
def __init__(self, size, mhcAsrt=False): self.organisms = [] self.mhc = mhcAsrt for i in range(0, size / 2): self.organisms.append(Organism(0)) self.organisms.append(Organism(1)) self.orgsFile = open('organisms.txt', 'w') self.writeOrganisms("Year\tInit\tAfterDeath\tAfterBirth\tMHC\t") self.paraFile = open('parasites.txt', 'w') self.writeParasites("Year\tReproduce\tAlive") self.year = 0
def __init__(self, ecosystem, location=None, isNewborn=False): Organism.__init__(self, ecosystem, location) self.lifespanTicks = 35 * 365 * 24 * 60 # years * days * hours * mins self.maturityTicks = 5 * 365 * 24 * 60 self.hunger = 50 self.starvationLevel = 100 self.survivalProbability = .95 # they can regenerate, after all self.movementImpact = .1 # slowly crawl along the ocean floor self.__initializeAgeAndMaturity(isNewborn) self.__initializeSex()
def test_fitness(self): rules = [ Rule("A", 0, 1, True, "B"), Rule("B", 0, 1, False, "A"), Rule("C", 0, 1, False, "B"), Rule("A", 1, 1, False, "C"), Rule("B", 1, 1, True, "B"), Rule("C", 1, 1, True, "HALT"), ] o = Organism(rules) self.assertEqual(o.fitness(), 14)
def randomly_add_organisms(game_grid, probability, memories=None): for row in range(len(game_grid)): for column in range(len(game_grid[row])): if decision(probability): if memories: organism = Organism(row, column, memories=memories) else: organism = Organism(row, column) game_grid[row][column] = organism return game_grid
def make_kid(env, folder, orgfrom, kidnum, breedernum): org = Organism(orgfrom.genesequence) # create a new organism based off parent org.folder = folder.path # set organism folder org.logloc = "P_"+str(kidnum+1)+"_B_"+str(breedernum+1) # set log file representation of folder org.lineage_id = orgfrom.lineage_id org.is_primeval = False # Did not come from random, not primeval folder.org = org # place org in folder mutate(folder.org, env.mutations+env.adds*kidnum, env.weight, env.maxgenes) # mutate the gene and write mutation to file writec(folder.path, folder.org) if env.debug == True: call('g++ '+ folder.path + '*.cpp ./habitat/biosort.o -o ' + folder.path + 'organism.out -g -O0', shell = True) else: call('g++ '+ folder.path + '*.cpp ./habitat/biosort.o -o ' + folder.path + 'organism.out -O0', shell = True)
def add_organism(cell_screen, chromosome): while True: organism_x = random.randint(0, cell_screen.width - 1 - chromosome.width) organism_y = random.randint( 0, cell_screen.height - 1 - chromosome.height()) organism_candidate = Organism(cell_screen, (organism_x, organism_y), chromosome) if not (organism_candidate.conflicts_with_any_of( cell_screen.organisms)): cell_screen.organisms.append(organism_candidate) return
def crossover(self, parents): (firstParent, secondParent) = parents firstChild = [] secondChild = [] for i in range(8): if random.random() > 0.5: firstChild.append(firstParent.playerParam[i]) else: firstChild.append(secondParent.playerParam[i]) if random.random() > 0.5: secondChild.append(secondParent.playerParam[i]) else: secondChild.append(firstParent.playerParam[i]) return (Organism(firstChild), Organism(secondChild))
def reproduce(parents): children = [] #divide the parents into gorups of two #for each couple, generate two children for i in range(len(parents) / 2): p1 = parents[i] i += 1 p2 = parents[i] s1, s2 = get_structs(p1, p2) n1, n2, n3, n4 = add_noise(p1, p2) child1 = Organism(n1, n2, s1) child2 = Organism(n3, n4, s2) children.append(child1) children.append(child2) return children
def __init__(self, ecosystem, lifespanYears, maturityYears, location=None, isNewborn=False): Organism.__init__(self, ecosystem, location) self.lifespanTicks = lifespanYears * 365 * 24 * 60 # convert to mins self.maturityTicks = maturityYears * 365 * 24 * 60 self.hunger = 10 self.starvationLevel = 20 self.__initializeSex() self.__initializeAgeAndMaturity(isNewborn)
def load_universe(fn): """ Load dataset file from JSON. Parameters ---------- fn : str Input filename of saved universe dataset. Returns ------- population_dict : dict A dict of Organism objects reconstructed from the saved dataset. world : World World object reconstructed from the saved dataset. """ with open(fn, 'r') as f: universe_dict = json.load(f) world = World(universe_dict['world']) population_dict_json = universe_dict['population'] population_dict = {} for species in population_dict_json: population_dict[species] = {} population_dict[species]['statistics'] = copy.deepcopy( population_dict_json[species]['statistics']) population_dict[species]['organisms'] = [ Organism(organism_dict) for organism_dict in population_dict_json[species]['organisms'] ] return population_dict, world
def add_organism(self, code): """ Adds a new organism with the given code. The code should be written as a list. Should not be used during the simulation phases and updating of the organisms. """ self.organisms.append(Organism(self.env, CURDL_code(code)))
def evolution(self): population = self.initPopulation(self.populationSize) generations = self.numberOfGenerations searchDepth = self.searchDepth for generation in range(generations): print("Generation " + str(generation) + "\n") (parents, population) = self.selection(population) children = self.crossover(parents) population.append(children[0]) population.append(children[1]) population = self.mutation(population) Organism.pickleOrganisms(population, 'generation' + str(generation) + '.pkl') return population
def createDescendant(self, settings, organism): # If higher than a treshold multipied with 2, it could have a descendant if(organism.fitness >= (settings['fission']*2)): organism.fitness -= settings['fission'] # Copy parameters parameters = organism.get_parameters() # Create descendant with mutation self.organisms.append(Organism(settings, parameters=parameters))
def click(self, keys): pos = pygame.mouse.get_pos() result = self.get_organism(pos) # print the contents of the location if result is not None: print(result) else: if keys[pygame.K_o]: new_organism = Organism(pos[0], pos[1]) new_organism.randomize() self.population.append(new_organism) elif keys[pygame.K_f]: new_plant = Plant(pygame.Rect(pos[0], pos[1], 6, 6)) self.vegetation.append(new_plant) elif keys[pygame.K_p]: new_predator = Predator(pos[0], pos[1]) new_predator.randomize() self.population.append(new_predator)
def __init__(self, inputs: list, outputs: list, simulation): super().__init__() self.simulation = simulation god = Organism(inputs, outputs) self.populate(god) for _ in range(config.generations): self.simulate() self.speciate() self.replicate()
def crossover(parent1: Organism, parent2: Organism, method: str) -> Tuple: """ Convenience function for computing two children via crossover :param parent1: Organism :param parent2: Organism :param method: 'pmx', 'order_based', 'position_based' or 'random' :return: two children """ return parent1.crossover(parent2, method=method)
def create_new_organisms(self, number_of_organisms): # Chose the number of new organisms of each category proportionally # to the initial number of organisms of each category: total = 0 for category_name in self.settings['organisms']: total += self.settings['organisms'][category_name][ 'initial number of organisms'] for category_name in self.settings['organisms']: n = (self.settings['organisms'][category_name] ['initial number of organisms'] * number_of_organisms) / total for _ in range(n): new_organism = Organism(parent_ecosystem=self) new_organism.configure_with_category_settings( self.settings['organisms'][category_name]) # This adds new_organism to self.newborns and to self.biotope # in a random location: self.add_organism(new_organism) self.organisms_list += self.newborns self.newborns = []
def placeOrganisms(self): for i in range(20): a = random.randrange(0, 100) o1 = Organism(self.speed_a, self.sense_a, self.wisdom_a, self.size_a, 0, a) o2 = Organism(self.speed_a, self.sense_a, self.wisdom_a, self.size_a, a, 0) o3 = Organism(self.speed_a, self.sense_a, self.wisdom_a, self.size_a, 100, a) o4 = Organism(self.speed_a, self.sense_a, self.wisdom_a, self.size_a, a, 100) self.originalOrganisms.append(o1) self.originalOrganisms.append(o2) self.originalOrganisms.append(o3) self.originalOrganisms.append(o4) self.originalOrganisms.append(o1) self.originalOrganisms.append(o2) self.originalOrganisms.append(o3) self.originalOrganisms.append(o4)
def createPlayer(self): money = 40 print( 'You have 40 to spend on the four traits: speed, sense, wisdom, size.\nIf you dont follow the limit for traits the program might crash and you might lose the data \n' ) input('press any key to continue') os.system('clear') speedp, sensep, wisdomp, sizep = getFixedInput(5, 15, 40) player = Organism(speed, sensep, wisdomp, sizep, 0, 34, 'player') self.originalOrganisms.append(player) self.organisms.append(player)
def init_organisms(self): screen_width, screen_height = self.screen_bounds.bounds() for x in range(0, 10): rand_pos = Vector(randint(100, screen_width - 100), randint(100, screen_height - 100)) rand_vel = Vector(randint(2, Vector.MAX_SPEED), randint(2, Vector.MAX_SPEED)) rand_organism = Organism( rand_pos, rand_vel, 30, (randint(0, 255), randint(0, 255), randint(0, 255))) self.organisms.add(rand_organism)
def __init__(self, ecosystem, location=None, isNewborn=False): Organism.__init__(self, ecosystem, location) if isNewborn: self.ticksAlive = 0 else: # Give insantiated manatee random age self.ticksAlive = random.randint(0, 60) # Set gender self.sex = "M" if random.randint(0, 1) == 0 else "F" # Only needed for random age setter, but either way, check maturity self.checkMaturity() # Who knew? Manatees can live up to 60 years old self.lifespanTicks = 60 * 365 * 24 * 60 # years * days * hours * mins self.survivalProbability = 0.2 # don't think they are the best survivors self.movementImpact = .1 self.hunger = 50 self.ticksSinceLastChild = 0
def initialize_organisms(self): print 'initialize_organisms' """ PRE-CONDITIONS: This initialization must be called AFTER self.initialize_biotope, because we use here Biotope.seek_free_location """ for category_name in self.settings['organisms']: category_settings = self.settings['organisms'][category_name] number_of_organisms = category_settings[ 'initial number of organisms'] for _ in range(number_of_organisms): new_organism = Organism(parent_ecosystem=self) new_organism.configure_with_category_settings( category_settings) # This adds new_organism to self.newborns and to self.biotope # in a random location: self.add_organism(new_organism) self.organisms_list += self.newborns self.newborns = []
def __init__(self, settings): SceneBase.__init__(self) self.highestSc = 0 #--- Add food to the map ---------------+ self.foods = [] for i in range(0, settings['food_num']): self.foods.append(Food(settings)) #--- Add organisms to the map ---------------+ self.organisms = [] for i in range(0, settings['pop_size']): self.organisms.append(Organism(settings, name= f'gen[x]-org[{str(i)}]' ))
def initPopulation(self, orgNumber): return [ Organism([ random.uniform(1, 3), random.uniform(1, 3), random.randint(10, 30), random.randint(5, 25), random.randint(10, 30), random.randint(10, 30), random.randint(0, 10), random.randint(0, 20) ]) for _ in range(orgNumber) ]
def Update(self, settings): # Set the default food color. for food in self.foods: if(food.dead == False): food.notInVision() # Array for the organism that we will keep newOrganisms = [] highestScore = 0 # Update location, find foods for organism in self.organisms: # Record highest score if(organism.score > highestScore): highestScore = organism.score organism.color = (220,80,220) else: organism.color = (40,40,220) # Update the location of the organisms organism.update_pos(settings) # Check starvation self.starve(settings, organism, newOrganisms) # Throws the organism to the other side of the map. self.borderControl(settings, organism) # Handles feeding, and in vision coloring target = self.interractWithFood(settings, organism) # Creates a child for the organism if it has enough food self.createDescendant(settings, organism) # TODO # I might want to pass everything or at least # the closes 5 thing to the brain to think about it organism.think(settings, target) self.organisms = newOrganisms # If there are less organism than defined create new ones if(len(self.organisms) < settings['pop_size']): self.organisms.append(Organism(settings)) if(self.highestSc != highestScore): self.highestSc = highestScore print("Highest Score:", self.highestSc)
def update_states(self): """ This function makes every organism decide what's his next state (not location) is going to be. (infected / healthy) """ if self.K == MAX_NEIGHBORS: return for o in self.organisms: if not o.is_healthy(): continue neighbors = [] locations = self.neighbors_locations(o)[:(MAX_NEIGHBORS - self.K)] for x, y in locations: neighbors.append(Organism(x, y, self.automaton[x][y])) o.update_state(neighbors, self) self._update_automaton()
class TestOrganism(TC): def setUp(self): self.value = bitstring.Bitstring("100") lookup = [{0: 1, 1: 0.5}, {0: 0.2, 1: 0.4}, {0: 0.1, 1: 0.8}] deps = [[0], [1], [2]] model = nk_model.NKModelSimple(deps, lookup) self.org = Organism(self.value, nk_model=model) def test_init(self): self.assertEqual(self.org.value, self.value) def test_mutate(self): self.assertNotEqual(self.org, self.org.mutate()) def test_without_nk_model(self): with self.assertRaises(ValueError): Organism(self.value) def test_fitness(self): expected_fit = (1 + 0.2 + 0.8) / float(3) self.assertEqual(expected_fit, self.org.fitness)
def reproduce(self): self.children = [Organism.reproduce(p1, p2) for (p1, p2) in zip(self.parents1, self.parents2)] self.population += self.children self.population = sorted(self.population, key=lambda org: org.fitness, reverse=True)[:self.pop_size]
class TestPopulation(unittest.TestCase): def setUp(self): self.col = Colicin(0) self.imm = Immunity(-5, 5) self.org = Organism([self.col], [self.imm]) self.pop = Population([self.org.duplicate() for _ in range(10)]) def test_len(self): self.assertEqual(len(self.pop), 10) def test_replicate(self): self.pop.replicate() self.assertEqual(self.pop.pop.count(self.org), 10) self.assertEqual(len(self.pop), 20) def test_iter(self): for org in self.pop: self.assertEqual(org, self.org) else: return self.fail() def test_remove_self_toxic(self): org_toxic = Organism([Colicin(0)], [Immunity(10, 5)]) org_not_toxic = Organism([Colicin(0)], [Immunity(0, 5)]) self.pop.pop = [org_not_toxic, org_toxic] self.assertEqual(len(self.pop), 2) self.pop.remove_self_toxic() self.assertEqual(len(self.pop), 1) self.assertSequenceEqual(self.pop.pop, [org_not_toxic]) def test_cull_by_all_colicins(self): org_winner = Organism([Colicin(5)], [Immunity(0, 5)]) self.pop.pop.append(org_winner) self.pop.cull_by_all_colicins() self.assertSequenceEqual(self.pop.pop, [org_winner]) def test_cull_by_all_colicins_extinction(self): org_other = Organism([Colicin(5)], [Immunity(10, 5)]) self.pop.pop.append(org_other) self.pop.cull_by_all_colicins() self.assertEqual(len(self.pop), 0) def test_cull_by_single_colicin(self): org_other = Organism([Colicin(100)], [Immunity(100, 5)]) self.pop.pop.extend(org_other for _ in range(10)) self.pop.cull_by_single_colicin() self.assertEqual(len(self.pop), 10) def test_cull_by_single_colicin_extinction(self): self.pop.cull_by_single_colicin(Colicin(5)) self.assertEqual(len(self.pop), 0) def test_cull_by_iterative_colicin(self): org_winner = Organism([Colicin(5)], [Immunity(0, 5)]) self.pop.pop.append(org_winner) self.pop.cull_by_iterative_colicin() self.assertSequenceEqual(self.pop.pop, [org_winner]) def test_cull_by_iterative_colicin_extinction(self): org_other = Organism([Colicin(5)], [Immunity(10, 5)]) self.pop.pop.extend(org_other for _ in range(10)) self.pop.cull_by_iterative_colicin() self.assertEqual(len(self.pop), 10) def test_colicins_produced(self): colicins = set(self.pop.colicins_produced()) self.assertSetEqual({self.col}, colicins) other_colicin = Colicin(5) self.pop.pop.append(Organism([other_colicin], [Immunity(0, 5)])) colicins = set(self.pop.colicins_produced()) self.assertSetEqual({self.col, other_colicin}, colicins) def test_sample_with_replacement(self): self.pop.pop.extend(self.org for _ in range(20)) self.assertEqual(len(self.pop), 30) self.pop.sample_with_replacement() self.assertEqual(len(self.pop), 10) self.pop.pop = self.pop.pop[::2] self.assertEqual(len(self.pop), 5) self.pop.sample_with_replacement() self.assertEqual(len(self.pop), 10) self.assertEqual(self.pop.carrying_capacity, 10) def test_advance_generation(self): self.pop.advance_generation() self.assertEqual(len(self.pop), 10)
def setUp(self): self.col = Colicin(0) self.imm = Immunity(-5, 5) self.org = Organism([self.col], [self.imm]) self.pop = Population([self.org.duplicate() for _ in range(10)])
import subprocess from organism import Organism import random as rand TRAIN_SPLIT = 75 MAX_GENERATIONS = 20 MAX_EPOCHS = 1000000 VALIDATION_PERCENT = 15 POPULATION_SIZE = 10 MAX_HIDDEN_LAYERS = 3 MAX_HIDDEN_NODES = 15 BSSF = Organism(0, 0, 0) BSSF.set_score(0) def initialize_pop(): population = [] for i in range(POPULATION_SIZE): rate = rand.random() momentum = rand.random() hidden_layers = rand.randint(1, MAX_HIDDEN_LAYERS) struct = "" first = True for j in range(hidden_layers): if not first: struct += "," first = False struct += str(rand.randint(1, MAX_HIDDEN_NODES)) org = Organism(rate, momentum, struct) population.append(org)
def update_BSSF(org): global BSSF BSSF = Organism(org.rate, org.momentum, org.structure) BSSF.set_score(org.score) print org.rate, org.momentum, org.structure, org.score
def spawn_organism(self): org = Organism(self.genome.get_genes()) org.species = self return org
def test_fitness_not_halt(self): rules = [Rule("A", 0, 1, True, "A"), Rule("A", 1, 1, True, "A")] o = Organism(rules) self.assertEqual(o.fitness(), 0)
def __init__(self, genotype, parasites, mhc): Organism.__init__(self, genotype, parasites)
filename = argv[1] fasta = open(filename,"r") def parse_fasta(filename): sequence = "" for line in filename: if (not line.startswith(">")): sequence = sequence + line sequence.replace("\n", "") return sequence sequence = parse_fasta(fasta) environment = Environment(0.000000001, 10) organism = Organism(sequence) environment.population_list.append(organism) start = time.clock() for organism in environment.population_list: print "-" * 20 print "Current organism: ", organism organism.transcribe() organism.translate() environment.population_list.append(organism.reproduce()) print "Population:", len(environment.population_list) print environment.population_list print "-" * 20 if len(environment.population_list) >= environment.carrying_capacity: break
def reproduce(self, generation, pop, sorted_species): champ_done = False mut_power = neat.weight_mut_power total_fitness = 0.0 if self.expected_offspring > 0 and len(self.organisms) == 0: return False poolsize = len(self.organisms) - 1 thechamp_i = 0 for count in range(0, self.expected_offspring): mut_struct_baby = False mate_baby = False outside = False mom = dad = None if self.organisms[thechamp_i].super_champ_offspring > 0: dprint(DEBUG_CHECK, "super_champ_offspring()") mom_i = thechamp_i mom = self.organisms[mom_i] new_genome = mom.gnome.duplicate(count) if self.organisms[thechamp_i].super_champ_offspring == 1: pass if self.organisms[thechamp_i].super_champ_offspring > 1: if neat.randfloat() < 0.8 or neat.mutate_add_link_prob == 0.0: new_genome.mutate_link_weights(mut_power, 1.0, Genome.GAUSSIAN) else: net_analogue = new_genome.genesis(generation) ok, pop.cur_innov_num = \ new_genome.mutate_add_link(pop.innovations, pop.cur_innov_num, neat.newlink_tries) net_analogue = None mut_struct_baby = True # baby = Organism() baby.SetFromGenome(0.0, new_genome, generation) if self.organisms[thechamp_i].super_champ_offspring == 1: if self.organisms[thechamp_i].pop_champ: baby.pop_champ_child = True baby.high_fit = mom.orig_fitness # self.organisms[thechamp_i].super_champ_offspring -= 1 self.verify_baby(baby, mom, dad) # super_champ_offspring > 0 elif (not champ_done) and (self.expected_offspring > 5): dprint(DEBUG_CHECK, "champ()") mom_i = thechamp_i mom = self.organisms[mom_i] new_genome = mom.gnome.duplicate(count) baby = Organism() baby.SetFromGenome(0.0, new_genome, generation) champ_done = True self.verify_baby(baby, mom, dad) # (not champ_done) and (self.expected_offspring > 5) elif (neat.randfloat() < neat.mutate_only_prob) or (poolsize == 0): dprint(DEBUG_CHECK, "mutate_only()") mom_i = neat.randint(0, poolsize) mom = self.organisms[mom_i] new_genome = mom.gnome.duplicate(count) self.verify_genome(new_genome) if neat.randfloat() < neat.mutate_add_node_prob: dprint(DEBUG_INTEGRITY, "a: pop.cur_node_id:", pop.cur_node_id) ok, pop.cur_node_id, pop.cur_innov_num = \ new_genome.mutate_add_node(pop.innovations, pop.cur_node_id, pop.cur_innov_num) dprint(DEBUG_INTEGRITY, "b: pop.cur_node_id:", pop.cur_node_id) mut_struct_baby = True self.verify_genome(new_genome) elif neat.randfloat() < neat.mutate_add_link_prob: net_analogue = new_genome.genesis(generation) ok, pop.cur_innov_num = \ new_genome.mutate_add_link(pop.innovations, pop.cur_innov_num, neat.newlink_tries) net_analogue = None mut_struct_baby = True self.verify_genome(new_genome) else: if neat.randfloat() < neat.mutate_random_trait_prob: new_genome.mutate_random_trait() self.verify_genome(new_genome) if neat.randfloat() < neat.mutate_link_trait_prob: new_genome.mutate_link_trait(1) self.verify_genome(new_genome) if neat.randfloat() < neat.mutate_node_trait_prob: new_genome.mutate_node_trait(1) self.verify_genome(new_genome) if neat.randfloat() < neat.mutate_link_weights_prob: new_genome.mutate_link_weights(mut_power, 1.0, Genome.GAUSSIAN) self.verify_genome(new_genome) if neat.randfloat() < neat.mutate_toggle_enable_prob: new_genome.mutate_toggle_enable(1) self.verify_genome(new_genome) if neat.randfloat() < neat.mutate_gene_reenable_prob: new_genome.mutate_gene_reenable() self.verify_genome(new_genome) baby = Organism() baby.SetFromGenome(0.0, new_genome, generation) self.verify_baby(baby, mom, dad) # (neat.randfloat() < neat.mutate_only_prob) or (poolsize == 0) else: mom_i = neat.randint(0, poolsize) mom = self.organisms[mom_i] if neat.randfloat() > neat.interspecies_mate_rate: # within species dad_i = neat.randint(0, poolsize) dad = self.organisms[dad_i] else: # outside species randspecies = self giveup = 0 while (randspecies == self) and (giveup < 5): randmult = neat.gaussrand() / 4. if randmult > 1.0: randmult = 1.0 randspeciesnum = int(math.floor( (randmult * (len(sorted_species) - 1.0)) + 0.5 )) randspecies = sorted_species[randspeciesnum] giveup += 1 dad = randspecies.organisms[0] outside = True if neat.randfloat() < neat.mate_multipoint_prob: dprint(DEBUG_CHECK, "mate_multipoint()") new_genome = mom.gnome.mate_multipoint(dad.gnome, count, mom.orig_fitness, dad.orig_fitness, outside) elif neat.randfloat() < neat.mate_multipoint_avg_prob / (neat.mate_multipoint_avg_prob+neat.mate_singlepoint_prob): dprint(DEBUG_CHECK, "mate_multipoint_avg()") new_genome = mom.gnome.mate_multipoint_avg(dad.gnome, count, mom.orig_fitness, dad.orig_fitness, outside) else: dprint(DEBUG_CHECK, "mate_singlepoint()") new_genome = mom.gnome.mate_singlepoint(dad.gnome, count) mate_baby = True if ((neat.randfloat() > neat.mate_only_prob) or (dad.gnome.genome_id == mom.gnome.genome_id) or (dad.gnome.compatibility(mom.gnome) == 0.0)): dprint(DEBUG_CHECK, "mate_and_mutate()") if neat.randfloat() < neat.mutate_add_node_prob: dprint(DEBUG_INTEGRITY, "a: pop.cur_node_id:", pop.cur_node_id) ok, pop.cur_node_id, pop.cur_innov_num = \ new_genome.mutate_add_node(pop.innovations, pop.cur_node_id, pop.cur_innov_num) dprint(DEBUG_INTEGRITY, "b: pop.cur_node_id:", pop.cur_node_id) mut_struct_baby = True elif neat.randfloat() < neat.mutate_add_link_prob: net_analogue = new_genome.genesis(generation) ok, pop.cur_innov_num = \ new_genome.mutate_add_link(pop.innovations, pop.cur_innov_num, neat.newlink_tries) net_analogue = None mut_struct_baby = True else: if neat.randfloat() < neat.mutate_random_trait_prob: new_genome.mutate_random_trait() if neat.randfloat() < neat.mutate_link_trait_prob: new_genome.mutate_link_trait(1) if neat.randfloat() < neat.mutate_node_trait_prob: new_genome.mutate_node_trait(1) if neat.randfloat() < neat.mutate_link_weights_prob: new_genome.mutate_link_weights(mut_power, 1.0, Genome.GAUSSIAN) if neat.randfloat() < neat.mutate_toggle_enable_prob: new_genome.mutate_toggle_enable(1) if neat.randfloat() < neat.mutate_gene_reenable_prob: new_genome.mutate_gene_reenable() baby = Organism() baby.SetFromGenome(0.0, new_genome, generation) self.verify_baby(baby, mom, dad) else: dprint(DEBUG_CHECK, "mate_only()") baby = Organism() baby.SetFromGenome(0.0, new_genome, generation) self.verify_baby(baby, mom, dad) # else baby.mut_struct_baby = mut_struct_baby baby.mate_baby = mate_baby curspecies_i = 0 found = False while (curspecies_i < len(pop.species)) and (not found): comporg = pop.species[curspecies_i].first() if comporg == None: curspecies_i += 1 elif baby.gnome.compatibility(comporg.gnome) < neat.compat_threshold: pop.species[curspecies_i].add_Organism(baby) baby.species = pop.species[curspecies_i] found = True else: curspecies_i += 1 # if not found: pop.last_species += 1 newspecies = Species() newspecies.SetFromIdAndNovel(pop.last_species, True) pop.species.append(newspecies) newspecies.add_Organism(baby) baby.species = newspecies # for count in self.expected_offspring return True
def start(self, movers, eaters, stroke): self.eaters = eaters self.movers = movers self.stroke = stroke self.organisms = Organism.generate(self.gui.organisms, self.lower_grid.max_x, self.lower_grid.max_y, self)
def setUp(self): self.value = bitstring.Bitstring("100") lookup = [{0: 1, 1: 0.5}, {0: 0.2, 1: 0.4}, {0: 0.1, 1: 0.8}] deps = [[0], [1], [2]] model = nk_model.NKModelSimple(deps, lookup) self.org = Organism(self.value, nk_model=model)
def init_random(size=10, mutation=0.3, solve_method="logistic"): new_pop = Population(size, mutation) new_pop.population = [Organism.init_random(np.random.randint(5, Organism.count), solve_method) for _ in xrange(size)] return new_pop