Added functionality to load and save a brain

brain.py

 import numpy as np
 import random
 import copy
+import pickle
 
 
 class Brain:
 
-    def __init__(self, size):
+    def __init__(self, size, load_brain):
         self.directions = []
         self.step = 0
+        if load_brain:
+            self.load()
+        else:
             self.increase_moves(size)
 
     def get_move(self):
@@ -22,7 +26,7 @@ class Brain:
 
     # returns a copy of the given brain
     def clone(self):
-        clone = Brain(len(self.directions))
+        clone = Brain(len(self.directions), False)
         for i in range(len(self.directions)):
             clone.directions[i] = copy.copy(self.directions[i])
         return clone
@@ -33,8 +37,15 @@ class Brain:
             if random.random() < 0.1:  # changes roughly 10% of the movements
                 self.directions[i] = np.random.uniform(-1, 1, 4)
 
+    def save(self):
+        with open('best_brain', 'wb') as fp:
+            pickle.dump(self.directions, fp)
+
+    def load(self):
+        with open('best_brain', 'rb') as fp:
+            self.directions = pickle.load(fp)
 
 if __name__ == '__main__':  # for debugging
-    brain_inst = Brain(100)
+    brain_inst = Brain(100, True)
     print(brain_inst.directions)
     print(len(brain_inst.directions))

main.py

-import gym
 from population import Population
 import time
-import numpy as np
 import matplotlib.pyplot as plt
 
 INCREASE_BY = 5
 BRAIN_SIZE = 50
 POP_SIZE = 50
 GAME_CANCELLED = False
+LOAD_BRAIN = True
 
 if __name__ == '__main__':
-    population = Population(POP_SIZE, BRAIN_SIZE)
+    population = Population(POP_SIZE, BRAIN_SIZE, LOAD_BRAIN)
 
     while GAME_CANCELLED is False:  # this is our game
         if population.all_players_finished():  # this is our genetic algorithm after one generation of players

population.py

 import numpy as np
-
-from walker import Walker
-import gym
 import random
 import logging
 import copy
+from walker import Walker
 
-MAX_STEPS = 10000
+MAX_STEPS = 1599  # after 1600 steps the Environment gives us a done anyway.
 
 
 class Population:
 
-    def __init__(self, size, brain_size):
+    def __init__(self, size, brain_size, load_brain):
         self.size = size
         self.brain_size = brain_size
         self.fitness_sum = 0.0
@@ -23,13 +21,14 @@ class Population:
         self.envs = []
         self.fitnesses = None
         for i in range(self.size):
-            self.envs.append(gym.make('BipedalWalker-v3'))
-            self.walkers.append(Walker(self.envs[i], self.brain_size))
+            self.walkers.append(Walker(self.brain_size, load_brain))
         self.reset_environments()
+        if load_brain:
+            self.mutate_babies()
 
     def reset_environments(self):
-        for env in self.envs:
-            env.reset()
+        for walker in self.walkers:
+            walker.reset_environment()
 
     def update(self):
         for walker in self.walkers:
@@ -62,7 +61,7 @@ class Population:
             #new_walkers.append(Walker(self.envs[i], self.brain_size))
         self.calculate_fitness_sum()
         self.set_best_walker()
-
+        self.walkers[self.best_walker_index].brain.save()
         # the champion lives on
         new_walkers = [self.walkers[self.best_walker_index].get_baby()]
         new_walkers[0].is_best = True

walker.py

 from brain import Brain
-
+import gym
 
 class Walker:
 
-    def __init__(self, env, brain_size):
-        self.brain = Brain(brain_size)  # new brain with X instructions
+    def __init__(self, brain_size, load_brain):
+        self.brain = Brain(brain_size, load_brain)  # new brain with X instructions
         self.dead = False
         self.reached_goal = False
         self.is_best = False  # true if this dot is the best dot from the previous generation
         self.fitness = 0.0
-        self.env = env
+        self.env = gym.make('BipedalWalker-v3')
         # self.pos = copy.copy(self.map.startpoint)
 
     def update(self):  # moves the dot according to the brains directions
@@ -36,7 +36,11 @@ class Walker:
              self.fitness = 1 / (self.map.get_closest_distance(self.pos[X], self.pos[Y]) ** 2)
          return self.fitness"""
 
+    def reset_environment(self):
+        self.env.reset()
+
     def get_baby(self):
-        baby = Walker(self.env, 0)
+        baby = Walker(0, False)
         baby.brain = self.brain.clone()  # babies have the same brain as their parents
+        self.env.close()
         return baby