def main():
print_run_info()
generation = Generation(POPULATION, ELITE, CROSSOVER, MUTATE)
generation_avg_fitness_list = [generation.avg_solution_fitness]
run_count = 1
print('{}, {}'.format(run_count, generation.avg_solution_fitness))
for i in range(1, 3):
solution_data = []
solution_data = solution_data + generation.elites + generation.untouched
mutated_solutions = []
crossedover_solutions = []
for item in generation.mutations:
mutated_solutions.append(item.mutate())
for i in range(0, int(len(generation.crossovers) / 2)):
item = generation.crossovers[i]
other_item = generation.crossovers[len(generation.crossovers) - i -
1]
for new_item in item.crossover(other_item):
crossedover_solutions.append(new_item)
solution_data = solution_data + mutated_solutions + crossedover_solutions
generation = Generation(POPULATION, ELITE, CROSSOVER, MUTATE,
solution_data)
run_count = run_count + 1
generation_avg_fitness_list.append(generation.avg_solution_fitness)
print('{}, {}'.format(run_count, generation.avg_solution_fitness))
def test_generation_for_equality(self):
mock_population = Mock(spec=Population)
mock_population.__eq__ = Mock(return_value=True)
mock_population.__hash__ = Mock(return_value=1)
generation1 = Generation(1, mock_population)
generation2 = Generation(1, mock_population)
self.assertEquals(generation2, generation1)
self.assertEquals(generation1.__hash__(), generation2.__hash__())
def doEvolve(self):
evolGeneration = Generation(self.parentGeneration, self.goal,
self.possibleAttributes)
while not self.evolutionFinish:
survivors = evolGeneration.sortTrolls()
evolGeneration = Generation(survivors, self.goal,
self.possibleAttributes)
for Troll in survivors:
if (Troll.look == self.goal.look) and (Troll.sex
== self.goal.sex):
print("The requested Troll was born!")
print("fix me: name is missing " + str(Troll.look) +
str(Troll.sex))
self.evolutionFinish = True
break
def main():
gencount = 100
#dimensions
d = 1053.7
ff = 0.5904
tline = 589.0957
tslab = 296.6
tstep = 10.5036
g0 = NIRZCG((d, ff, tline, tslab, tstep),(1750, 2250, 1001), target = 2000)
g0.evaluate()
oldbest = g0
genbest = list(zip(*g0.trans))
print(str(dt.time(dt.now())).split('.')[0],colored("seed:", 'cyan'),g0)
gen = Generation(25, g0)
for i in range(gencount):
#str(dt.time(dt.now())).split('.')[0],colored("gen "+str(i), 'cyan')
gen._evaluate(progress_txt = (str(dt.time(dt.now())).split('.')[0]+colored(" gen "+str(i), 'cyan')))
gen = gen.progeny()
genbest.append([t for wl,t in gen.best.trans])
if gen.best.fom > oldbest.fom:
print(colored("new best grating\n", 'green')+str(gen.best))
oldbest = gen.best
writecsv("iter_best.csv",list(zip(*genbest)),tuple(["wl",0]+list(range(1,gencount+1))))
def run(self):
max_unit = 0
for i in range(self.ran):
print("Generation ", i)
gen = Generation(self.p)
#gen.hand.print_cards()
gen.assign_unit_value(0)
#gen.print_stats()
gen.calc_fitness(self.step, 0)
#for i in range(p.size):
# print(gen.population.units[i].fitness)
if (i == self.ran - 1):
break
max_val = 0
for i in range(gen.population.size):
if (gen.population.units[i].fitness > max_val):
max_unit = gen.population.units[i]
max_val = gen.population.units[i].fitness
print(max_unit.fitness)
s = Step(gen)
gen.population.units = s.generate_mating_pool()
max_val = 0
max_unit = 0
for i in range(gen.population.size):
if (gen.population.units[i].fitness > max_val):
max_unit = gen.population.units[i]
max_val = gen.population.units[i].fitness
print(max_unit.weights)
return max_unit.weights
def __init__(self, representation="pool", L=12, shared_core=False):
super(GQN, self).__init__()
# Number of generative layers
self.L = L
self.shared_core = shared_core
# Representation network
self.representation = representation
if representation == "pyramid":
self.phi = Pyramid()
elif representation == "tower":
self.phi = Tower()
elif representation == "pool":
self.phi = Pool()
# Generation network
if shared_core:
self.inference_core = InferenceCore()
self.generation_core = GenerationCore()
else:
self.inference_core = nn.ModuleList(
[InferenceCore() for _ in range(L)])
self.generation_core = nn.ModuleList(
[GenerationCore() for _ in range(L)])
# Distribution
self.pi = Prior()
self.q = Inference()
self.g = Generation()
def __init__(self, parser, truecase_model):
"""
Perform syntactic simplification rules.
@param parser: parser server.
@param truecase_model: truecase model.
"""
#self.sentences = open(doc, "r").read().strip().split("\n")
## markers are separated by their most used sense
self.time = ['cuando', 'despues', 'antes', 'before', 'once']
self.concession = ['aunque', 'pero', 'sino', 'however', 'whereas']
self.justify = ['so', 'mientras']
self.condition = ['si']
self.condition2 = ['o']
self.addition = ['y']
## list of all markers for analysis purposes
self.cc = self.time + self.concession + self.justify + self.condition + self.addition + self.condition2
## list of relative pronouns
self.relpron = ['que', 'whose', 'which', 'who']
## initiates parser server
self.parser = parser
## Generation class instance
self.generation = Generation(self.time, self.concession, self.justify,
self.condition, self.condition2,
self.addition, self.cc, self.relpron,
truecase_model)
def testDone(self):
""""Test the Done method.
Produce a generation with a set of tasks. Set the cost of the task one by
one and verify that the Done method returns false before setting the cost
for all the tasks. After the costs of all the tasks are set, the Done method
should return true.
"""
random.seed(0)
testing_tasks = range(NUM_TASKS)
# The tasks for the generation to be tested.
tasks = [IdentifierMockTask(TEST_STAGE, t) for t in testing_tasks]
gen = Generation(set(tasks), None)
# Permute the list.
permutation = [(t * STRIDE) % NUM_TASKS for t in range(NUM_TASKS)]
permuted_tasks = [testing_tasks[index] for index in permutation]
# The Done method of the Generation should return false before all the tasks
# in the permuted list are set.
for testing_task in permuted_tasks:
assert not gen.Done()
# Mark a task as done by calling the UpdateTask method of the generation.
# Send the generation the task as well as its results.
gen.UpdateTask(IdentifierMockTask(TEST_STAGE, testing_task))
# The Done method should return true after all the tasks in the permuted
# list is set.
assert gen.Done()
def __init__(self):
pygame.init()
self.generation = Generation()
self.population = self.generation.population
self.gamespeed = 4
self.max_gamespeed = 10
self.high_score = 0
self.n_gen = 0
self.current_gen_score = 0
self.dinos = None
self.genomes = []
self.screen = pygame.display.set_mode(scr_size)
self.clock = pygame.time.Clock()
pygame.display.set_caption('Genetic T-Rex Rush')
self.jump_sound = pygame.mixer.Sound('sprites/jump.wav')
self.die_sound = pygame.mixer.Sound('sprites/die.wav')
self.checkPoint_sound = pygame.mixer.Sound('sprites/checkPoint.wav')
self.scores = []
self.fig = plt.figure(figsize=(int(width/100), 5))
self.ax = plt.axes()
plt.xlabel('Generation', fontsize=18)
plt.ylabel('Score', fontsize=16)
plt.show(block=False)
def __init__(self, doc):
"""
Perform syntactic simplification rules.
@param doc: document to be simplified.
"""
self.sentences = open(doc, "r").read().strip().split("\n")
## markers are separated by their most used sense
self.time = ['when', 'after', 'since', 'before', 'once']
self.concession = ['although', 'though', 'but', 'however', 'whereas']
self.justify = ['because', 'so', 'while']
self.condition = ['if']
self.condition2 = ['or']
self.addition = ['and']
## list of all markers for analysis purposes
self.cc = self.time + self.concession + self.justify + self.condition + self.addition + self.condition2
## list of relative pronouns
self.relpron = ['whom', 'whose', 'which', 'who']
## initiates parser server
self.parser = Parser()
## Generation class instance
self.generation = Generation(self.time, self.concession, self.justify,
self.condition, self.condition2,
self.addition, self.cc, self.relpron)
def __init__(self, parser, truecase_model):
"""
Perform syntactic simplification rules for Galician (this code is based on the one available at simpatico_ss/simplify.py for English).
TODO: Relative and conjoint clauses are not supported by the Galician parser. Functions for these cases were left here as examples for feature implementations.
@param parser: parser server.
@truecase_model: truecase model
"""
## markers are separated by their most used sense
self.time = ['when', 'after', 'since', 'before', 'once']
self.concession = ['although', 'though', 'but', 'however', 'whereas']
self.justify = ['because', 'so', 'while']
self.condition = ['if']
self.condition2 = ['or']
self.addition = ['and']
## list of all markers for analysis purposes
self.cc = self.time + self.concession + self.justify + self.condition + self.addition + self.condition2
## list of relative pronouns
self.relpron = ['whom', 'whose', 'which', 'who']
## initiates parser server
self.parser = parser
## Generation class instance
self.generation = Generation(self.time, self.concession, self.justify,
self.condition, self.condition2,
self.addition, self.cc, self.relpron,
truecase_model)
def test_generation_to_retrun_best_fit_people(self):
best = Mock(spec=DNA)
fitness = 5
mock_population = Mock(spec=Population)
mock_population.best_fit = Mock(return_value=(best, fitness))
generation = Generation(1, mock_population)
self.assertEquals((best, fitness), generation.best_fit())
def __init__(self, rows, cols):
"""Creates a game object."""
#self._board = Board(8, 8)
self._rows = rows
self._cols = cols
self._current_generation = Generation(rows, cols)
def main():
generation = Generation(100, [11, 11, 4, 4], 0.5, 10)
print("Starting the program at generation 0")
while True:
try:
command = input("Enter a command (sbs, asap, alap): ")
if command == "sbs":
generation.do_generation(render=True)
print("That was generation {}.".format(str(generation.age -
1)))
elif command == "asap":
generation.do_generation()
print("Just did generation {} as fast as possible.".format(
str(generation.age - 1)))
elif command == "alap":
print(
"Doing generations for as long as possible starting at generation {}."
.format(str(generation.age)))
print("Type Ctrl-C to exit the alaping")
while True:
try:
generation.do_generation()
print("Just did generation {}".format(
str(generation.age - 1)))
except KeyboardInterrupt:
print("Exiting alap")
break
else:
print("Not a valid command")
except KeyboardInterrupt:
print("Thanks for playing")
print("Exiting now")
sys.exit()
def __init__(self, island_model, *args, **kwargs):
super().__init__(*args, **kwargs)
self._island_model = island_model
# Assume existing members of the tree are a part of the founders
if len(island_model.individuals) > 0:
assert len(self._generations) is 0
self._generations.append(Generation(island_model.individuals))
def main():
generation = Generation()
while True:
generation.execute()
generation.keep_best_genomes()
generation.mutations()
def _initialise(self, target_string):
target_length = len(target_string)
nucleotides = Nucleotides(string.printable)
DNA.nucleotides = nucleotides
population_initialise = PopulationInitialise(nucleotides)
first_population = population_initialise.create(
population_size=self.population_size, structure_size=target_length)
first_generation = Generation(1, first_population)
return [first_generation]
def main():
generation = Generation()
while True:
generation.execute()
print("Done")
generation.keep_best_genomes()
print("Storing")
generation.mutations()
print("Mutated")
def test_generation_to_generate_next_generation(self):
mock_population1 = Mock(spec=Population)
mock_population2 = Mock(spec=Population)
mock_population1.next_population = Mock(return_value=mock_population2)
mock_target_DNA = Mock(spec=DNA)
generation1 = Generation(1, mock_population1)
generation2 = generation1.next_generation(mock_target_DNA)
self.assertEquals(generation2.number, 2)
self.assertEquals(generation2.population, mock_population2)
def main():
generation = Generation()
i=0
while True:
print("Generation "+str(i)+":")
i += 1
generation.execute()
generation.keep_best_genomes()
generation.mutations()
def test_count_living(self):
rows = 2
columns = 4
g = Generation(rows, columns)
g.assign_neighbors()
g._cells[0][0].live()
self.assertEqual(g.count_living(), 1)
g._cells[1][3].live()
self.assertEqual(g.count_living(), 2)
def main():
g = Generation(size=100,
elite=0.05,
mutate=0.10,
tournament=10,
mood=raw_input())
g.run(100, desired_length=13)
g.best.info()
lilypond.printPiece(g.best, 'best.ly')
lilypond.printPiece(g.worst, 'worst.ly')
def main():
generation = Generation()
lx, ly, rx, ry = get_location()
epoch = 0
while True:
epoch = epoch + 1
print("Geracao {}".format(epoch))
generation.execute(lx, ly, rx, ry, epoch)
generation.keep_best_genomes()
generation.mutations()
def createNewGeneration(generation, scorePerChild, ppid, pid):
if(generation.generation_i >= 10300):
growth = int(1*(generation.generation_i / 300))
else:
growth = 0
n_random = 6 + growth
n_elite = 2 + growth
n_mutated_elite = 2 + growth
#Crossover Rates
n_crossover_mutated_elite = 2 + growth
n_crossover_mutated_random = 2 + growth
n_crossover_unmutated_elite = 2 + growth
n_crossover_unmutated_random = 2 + growth
#Gets indices of the elite children of population
idxs_elite = heapq.nlargest(n_elite, range(len(scorePerChild)), key=scorePerChild.__getitem__)
idxs_elite = np.array(idxs_elite)
#print information about the best elite
if(generation.generation_i % 20 == 0):
print(str(scorePerChild[idxs_elite[0]]) + "/" + str(generation.num_clauses), generation.generation_i, len(generation.children), ppid, pid)
#Create children
elite_children = np.array(generation.children[idxs_elite])
random_children = np.array(createRandomChildren(n_random, generation.num_variables))
if(n_mutated_elite > len(elite_children)):
print("n_mutated_elite > elite_children")
n_mutated_elite = len(elite_children)
mutate_elite = np.array([mutate(elite_children[i]) for i in (0, n_mutated_elite-1)])
#Create Crossovers
crossover_unmutated_random = np.array(createCrossOvers(elite_children, random_children, n_crossover_unmutated_random))
crossover_unmutated_elite = np.array(createCrossOvers(elite_children, elite_children, n_crossover_unmutated_elite))
crossover_mutated_random = np.array(createCrossOvers(mutate_elite, random_children, n_crossover_mutated_random))
crossover_mutated_elite = np.array(createCrossOvers(elite_children, elite_children, n_crossover_mutated_elite))
# @todo make this more clean
temp = np.array([])
temp = np.append(temp, elite_children)
temp = np.append(temp,random_children)
temp = np.append(temp,mutate_elite)
temp = np.append(temp,crossover_unmutated_random)
temp = np.append(temp,crossover_unmutated_elite)
temp = np.append(temp,crossover_mutated_random)
temp = np.append(temp,crossover_mutated_elite)
temp = np.array(temp)
temp = temp.reshape(int(len(temp)/729), 729)
children = np.array(temp)
return Generation(generation, children, generation.num_clauses, generation.num_variables)
def main():
knapsack, items_number = read_input()
generation = Generation(items_number * 10, items_number)
process_generation(generation, knapsack)
for i in range(1, 11):
print("Before iteration {0} best individual is: {1}".format(
i,
generation.get_best().fitness))
generation.update_generation()
process_generation(generation, knapsack)
print("Final result is: {}".format(generation.get_best().fitness))
def parse_trial(trial_path):
with open(trial_path,'rb') as input_file:
trial_result = json.load(input_file)
generation_list = list()
for gen in trial_result['generationalData']:
individual_list = list()
for indi in gen['individualList']:
individual_list.append(
Individual(indi['UUID'], indi['parentUUID'], indi['switch'], indi['lightFirst'], indi['fitness']))
generation_list.append(Generation(gen['generationNumber'], individual_list))
trial = Trial(trial_result['config'], generation_list)
return trial
def main():
driver = webdriver.Chrome()
#driver.get('chrome://settings/clearBrowserData')
#driver.find_element_by_xpath('//settings-ui').send_keys(Keys.ENTER)
driver.get('chrome://dino')
generation = Generation(driver)
iteration = 0
while True:
iteration += 1
print('++++++++++++++++++++++++++++++++++++++++++++++++++')
print(' iteration:{0}'.format(iteration))
print('++++++++++++++++++++++++++++++++++++++++++++++++++')
generation.execute()
generation.keep_best_genomes()
generation.mutations()
def load_generation(filename):
if len(filename) <= 2 or filename[len(filename) - 2:len(filename)] != ".p":
filename = filename + ".p"
try:
generation = pickle.load(open(filename, "rb"))
print "Resuming from", filename
print "Last Generation Processed:", generation.num
score_str = "Sorted Scores"
for individual in generation.population:
score_str = score_str + " : {0}".format(individual.score)
print score_str
return generation
except IOError:
print "Could not open", filename + ",", "returning new Generation"
generation = Generation()
generation.populate()
return generation
def test_next_generation_block(self):
l = Cell.liveChar
d = Cell.deadChar
n = '\n'
state1 = n + l + l + \
n + l + l
g = Generation(2, 2)
g.assign_neighbors()
g._cells[0][0].live()
g._cells[0][1].live()
g._cells[1][0].live()
g._cells[1][1].live()
self.assertEqual(state1, str(g))
g = g.next_generation()
self.assertEqual(state1, str(g))
g = g.next_generation()
self.assertEqual(state1, str(g))
def generation_iterator(environment_type: str, env_carac: List[int],
nb_animals: List[int], nb_generation: int) -> List:
""" Retourne un tableau des moyennes par génération """
animal_evolution = Generation(environment_type, env_carac, nb_animals)
nb_generation = int(nb_generation)
result = []
result.append(animal_evolution.calc_moyenne())
for generation in range(nb_generation):
survivors = animal_evolution.natural_selection(
animal_evolution.animals)
sorted_animals = animal_evolution.sort_by_fitness(survivors)
animal_evolution.animals = animal_evolution.reproduction(
sorted_animals)
result.append(animal_evolution.calc_moyenne())
return result
