def test_randomize(self):
p1 = Population(num_nets=3, num_elite=1)
p1.elites = [p1.networks.pop()]
p2 = copy(p1)
p2.randomize()
self.assertEqual(p1.elites, p2.elites)
self.assertNotEqual(p1.networks, p2.networks)
def test_init_from_pop(self):
p = Population(num_nets=3, num_elite=1)
p = Population(num_nets=10, num_elite=3,
pop=p) # First two parameters should be ignored.
self.assertEqual(len(p.networks), 2)
self.assertEqual(len(p.elites), 1)
self.assertEqual(p.generation, 2)
self.assertGreater(p.similarity, 0.5)
def main():
game = Game(width=800, height=450)
population = Population(size=10, layers=(2, 6, 1), mutation_rate=0.4)
while not game.exit:
obstacles = ObstacleList(screen_width=game.screen.get_width(),
screen_height=game.screen.get_height(),
ob_width=30,
ob_vspace=100,
ob_hspace=200,
ob_speed=-300)
sim = Simulation(obstacles, population)
game.run(sim)
population.evolve()
game.quit()
def test_play_games(self):
p = Population(num_nets=3, num_elite=1)
p.elites = [p.networks.pop()]
p.play_games(2, include_elites=True, progress_bar=False)
self.assertEqual(p.elites[0].get_num_games_played(), 2)
[self.assertEqual(n.get_num_games_played(), 2) for n in p.networks]
p.play_games(2, include_elites=True, progress_bar=False,
thresh=1e20) # Impossibly high threshold.
self.assertEqual(p.elites[0].get_num_games_played(), 2)
[self.assertEqual(n.get_num_games_played(), 2) for n in p.networks]
p.play_games(2, include_elites=False, progress_bar=False)
self.assertEqual(p.elites[0].get_num_games_played(), 2)
[self.assertEqual(n.get_num_games_played(), 4) for n in p.networks]
def test_init_no_params(self):
with self.assertRaises(ValueError) as e:
Population()
self.assertIn('If pop is none, then both num_nets', str(e.exception))
def test_save(self):
p = Population(num_nets=3, num_elite=1)
with NamedTemporaryFile() as f:
p.save(f.name)
def test_get_sorted_networks(self):
p = Population(num_nets=3, num_elite=1)
p.elites = [p.networks.pop()]
p.play_games(2, include_elites=True, progress_bar=False)
self.assertEqual(len(p.get_sorted_networks(False)), 2)
self.assertEqual(len(p.get_sorted_networks(True)), 3)
def test_init_new_pop(self):
p = Population(num_nets=3, num_elite=1)
self.assertEqual(len(p.networks), 3)
self.assertLess(p.similarity, 0.7)
from genetics.population import Population
import numpy as np
pop = Population(250)
for i in range(50):
pop.next_generation()
print(np.mean(pop.fitness))
# pop.generation_best.visualize()
args = parser.parse_args()
if args.command == 'tests':
suite = TestLoader().discover('tests', pattern='*.py')
result = TextTestRunner(verbosity=2).run(suite)
result = 0 if result.wasSuccessful() else 1
exit(result)
cfg = read_config(args.config)
logger = init_logger()
renderer = DistributedRenderer()
qualifier = DistributedQualifier()
base_image_path = cfg['main']['populationPath'] + basename(cfg['main']['baseImage'])
fitnessMachine = MeshFitnessMachine(base_image_path, renderer, qualifier)
population = Population(MeshGenome, fitnessMachine)
population.generation = int(db.get('generation', default=0))
accuracy.register(population)
monitor.register(population)
if args.command == 'reset' or not population.generation:
population.initialize()
else:
population.load()
do('cp -v %s %s' % (cfg['main']['baseImage'], base_image_path))
try:
population.evolve()
except KeyboardInterrupt as ki:
pass
def run_micro_genetic_alg(num_generations, pop=None):
"""Run a micro-genetic algorithm to evolve a good neural network.
Each network plays 20 games and the weakest half are removed from the population. Then 30 more games are played and
the weakest half are again removed. Finally, for each remaining network whose average score is in range of the
elite network's lower bound, 250 more games are played. The top networks then go on to populate the next generation.
Every 30 generations, all non-elite networks are randomized to improve diversity.
Parameters
----------
num_generations : int
The total number of generations to run.
pop : Optional[Population]
Starting population. If None, one will be randomly generated.
Returns
-------
top_scores : List[float]
List of floats. The top average score in each generation.
best_net : NetworkPlayer
The trained networks that performs best.
"""
top_scores = []
top_network = None
for gen in range(num_generations):
pop = Population(NETS_PER_POP, NUM_ELITE, pop)
if not gen % 20 and gen > 0:
print('Randomizing non-elite networks to improve diversity.')
pop.randomize()
print(
f'Playing games for generation {pop.generation} ({gen + 1} of {num_generations})'
)
print('Playing first 20 games.')
pop.play_games(20, include_elites=False)
num_to_filter = NETS_PER_POP // 2 - len(pop.elites)
pop.networks = pop.get_sorted_networks(
include_elites=False)[:num_to_filter]
print('Playing next 30 games.')
pop.play_games(30, include_elites=False)
num_to_filter = NETS_PER_POP // 4 - len(pop.elites)
pop.networks = pop.get_sorted_networks(
include_elites=False)[:num_to_filter]
if not pop.elites:
print('Playing final 250 games to determine elites.')
pop.play_games(250, include_elites=False)
else:
elite = pop.elites[0]
log_st_err = np.std(np.log(elite.scores)) / np.sqrt(
elite.get_num_games_played())
thresh = elite.get_avg_score() / np.exp(
2 * log_st_err) # Approximate lower bound of score estimate.
print(f'Playing 250 games for networks above {np.rint(thresh)}.')
pop.play_games(250, include_elites=False, thresh=thresh)
if not pop.generation % 10 and pop.generation != 0:
pop.save(f'Generation{pop.generation}.pkl')
top_network = pop.get_sorted_networks(include_elites=True)[0]
top_scores.append(top_network.get_avg_score())
print('Best network\'s generation =', top_network.generation)
print('Best network\'s score =', np.rint(top_scores[-1]))
print('Best network\'s highest tile =',
np.rint(top_network.get_avg_highest_tile()), '\n')
plt.figure()
plt.title('Network Improvement vs Generation')
plt.xlabel('Generation')
plt.ylabel('Highest Score')
plt.loglog(top_scores)
plt.savefig('scores_per_generation.png')
pop.save(f'Generation{pop.generation}.pkl')
return top_scores, top_network
"""IMPORT STATEMENTS"""
# 3rd party modules
import numpy as np
# Local moduless
from genetics.population import Population
from genetics.visualize import visualize
from genetics.curves import T_cycloid
# test
if __name__ == '__main__':
pop = Population(100)
for generation in range(100):
pop.next_generation()
if generation % 10 == 0:
visualize(pop.generation_best)
print(
"Generation: {} \nBest time: {:.3f} | Average time: {:.3f} | Cycloid time: {:.3f}"
.format(generation, pop.generation_best.time, np.mean(pop.fitness),
T_cycloid))
# pop.hist_fitness_and_error()