def play_best_game(best_individual):
"""
Play the game with the best individual obtained from the genetic
algorithm.
best_individual: Best individual after the GA has finished.
return game score (int)
"""
game = DinoGame(fps=60)
state_matrix = np.zeros((3, N_ATTRIBUTES))
while not game.game_over:
state_matrix = update_state_matrix(game, state_matrix)
action = np.argmax(best_individual @ state_matrix.T)
game.step(action)
return game.get_score()
fit = calcular_fitness(jogo, ind)
print('Fitness: {:4.1f}'.format(jogo.get_score()))
###############################
# CÓDIGO QUE RODA O ALGORITMO #
###############################
# Referência: for loop (for x in lista)
# list.append()
# OBS: Todos os prints dentro dessa função são opcionais.
# Eles estão aqui para facilitar a visualização do algoritmo.
num_geracoes = 100
jogo = DinoGame(fps=50_000)
# Crie a população usando populacao_aleatoria(NUM_INDIVIDUOS)
populacao = populacao_aleatoria(NUM_INDIVIDUOS)
print('ger | fitness\n----+-' + '-' * 5 * NUM_INDIVIDUOS)
for ger in range(num_geracoes):
# Crie uma lista `fitness` com o fitness de cada indivíduo da população
# (usando a função calcular_fitness e um `for` loop).
fitness = []
for ind in populacao:
fitness.append(calcular_fitness(jogo, ind))
# Atualize a população usando a função próxima_geração.
populacao = proxima_geracao(populacao, fitness)
fit = calcular_fitness(jogo, ind)
print('Fitness: {:4.1f}'.format(jogo.get_score()))
###############################
# CÓDIGO QUE RODA O ALGORITMO #
###############################
# Referência: for loop (for x in lista)
# list.append()
# OBS: Todos os prints dentro dessa função são opcionais.
# Eles estão aqui para facilitar a visualização do algoritmo.
num_geracoes = 100
jogo = DinoGame(fps=50)
# Crie a população usando populacao_aleatoria(NUM_INDIVIDUOS)
populacao = populacao_aleatoria(NUM_INDIVIDUOS)
print('ger | fitness\n----+-' + '-' * 5 * NUM_INDIVIDUOS)
for ger in range(num_geracoes):
# Crie uma lista `fitness` com o fitness de cada indivíduo da população
# (usando a função calcular_fitness e um `for` loop).
# Atualize a população usando a função próxima_geração.
fitness = []
for individuo_g in populacao:
fitness_individuo = calcular_fitness(jogo, individuo_g)
if gen == 0:
log_file.write(f"GEN\tMEAN\tBEST\n")
if gen != N_GENERATIONS:
log_file.write(f"{gen}\t{mean_fitness}\t{best_fitness}\n")
else:
log_file.write(f"{gen}\t{mean_fitness}\t{best_fitness}")
print(f"GEN: {gen} \t MEAN: {mean_fitness} \t BEST: {best_fitness}")
#Paths
save_dir = save_parameters()
path_pop = os.path.join(save_dir, "population.npy")
path_fitness = os.path.join(save_dir, "fitness.npy")
path_best_idv = os.path.join(save_dir, "best_individual.npy")
#TODO Make so it can train again a population.
game = DinoGame(fps=1_000_000)
population = ga.initialize_population(POP_SIZE, N_ATTRIBUTES)
fitness = ga.calc_fitness(calc_fitness, population, game)
np.save(path_pop, population)
np.save(path_fitness, fitness)
best_fitness = save_best(population, fitness, 0, path_best_idv)
save_log(0, np.mean(fitness), best_fitness, save_dir)
for gen in range(N_GENERATIONS):
#Reproduction
# recombination and sum_value
idx_parents = ga.selection.parents(fitness, POP_SIZE)
new_pop0 = ga.crossover.recombination(population, P_CROSSOVER, idx_parents)
new_pop0 = ga.mutation.sum_value(new_pop0, P_MUTATION)
# one_point and multiply_value
idx_parents = ga.selection.parents(fitness, POP_SIZE)
new_pop1 = ga.crossover.one_point(population, P_CROSSOVER, idx_parents)
fit = calcular_fitness(jogo, ind)
print('Fitness: {:4.1f}'.format(jogo.get_score()))
###############################
# CÓDIGO QUE RODA O ALGORITMO #
###############################
# Referência: for loop (for x in lista)
# list.append()
# OBS: Todos os prints dentro dessa função são opcionais.
# Eles estão aqui para facilitar a visualização do algoritmo.
num_geracoes = 100
jogo = DinoGame(fps=0)
# Crie a população usando populacao_aleatoria(NUM_INDIVIDUOS)
populacao = populacao_aleatoria(NUM_INDIVIDUOS)
print('ger | fitness\n----+-' + '-' * 5 * NUM_INDIVIDUOS)
for ger in range(num_geracoes):
# Crie uma lista `fitness` com o fitness de cada indivíduo da população
# (usando a função calcular_fitness e um `for` loop).
# Atualize a população usando a função próxima_geração.
fitness = []
for i in populacao:
fitness.append(calcular_fitness(jogo, i))
fps_old = game.fps
game.fps = 100
ind = population [max (range (len)), key = lambda i: fitness [i])]
print ('Best Guy:', ind)
while True:
if input ('Press enter to run the best agent. Type q to exit.') == 'q':
game.fps = fps_old
return
fit = calculate_fitness (game, ind)
print ('Fitness: {: 4.1f}'. format (game.get_score ()))
num_generations = 100
game = DinoGame (fps = 50_000)
population = random_population (NUM_INDIVIDUES)
print ('ger | fitness \ n ---- + -' + '-' * 5 * NUM_INDIVIDUES)
for ger in range (num_generations):
fitness = []
for ind in population:
fitness.append (calculate_fitness (game, ind))
population = next_generation (population, fitness)
print ('{: 3} |' .format (ger),
'' .join ('{: 4d}'. format (s) for s in sorted (fitness, reverse = True)))
fitness = []
# Se vc passar o argumento `weights`, os indivíduos serão escolhidos com base nos pesos
# especificados (elementos com pesos maiores são escolhidos mais frequentemente).
# Uma ideia seria usar o fitness como peso.
ind1, ind2 = random.choices(populacao, k=2)
filho = crossover(ind1, ind2)
mutacao(filho)
proxima_ger.append(filho)
return proxima_ger
# OBS: Todos os prints abaixo são opcionais.
# Eles estão aqui para facilitar a visualização do algoritmo.
num_geracoes = 100
jogo = DinoGame(fps=50_000)
# Crie a população usando populacao_aleatoria(NUM_INDIVIDUOS)
populacao = populacao_aleatoria(NUM_INDIVIDUOS)
print('ger | fitness\n----+-' + '-' * 5 * NUM_INDIVIDUOS)
for ger in range(num_geracoes):
# Crie uma lista `fitness` com o fitness de cada indivíduo da população
# (usando a função calcular_fitness e um `for` loop).
fitness = []
for ind in populacao:
fitness.append(calcular_fitness(jogo, ind))
# Atualize a população usando a função próxima_geração.
populacao = proxima_geracao(populacao, fitness)