Move the mutation rate from class to algorithm. (#38)

* Move the mutation rate from class to algorithm.

If there was a specific reason for having the mutation rate in the
params class
let me know but I've moved it to better reflect that it's a property of
the algorithm. This is more in line with the fact that the
representation we write to file does not hold the mutation rate for
example.

This doesn't stop having algorithms that would have different
mutation rates for different parameter instances (it's just that the
algorithm would have to keep track of it).

* Add mutation rate arg to base class.

* Correct test.

* Remove rescaling of mutation rate.

* Move to params_kwargs which are handled by alg.

* Change probability of initial state mutation.

* Adjust scripts.

* Add ability to not overwrite mutation probability.

Author: drvinceknight

bin/ann_evolve.py

@@ -140,7 +140,7 @@ def parse_repr(cls, s):
 
     # Vars for the genetic algorithm
     population = int(arguments['--population'])
-    mutation_rate = float(arguments['--mu'])
+    mutation_probability = float(arguments['--mu'])
     generations = int(arguments['--generations'])
     bottleneck = int(arguments['--bottleneck'])
     output_filename = arguments['--output']
@@ -156,9 +156,13 @@ def parse_repr(cls, s):
     num_features = int(arguments['--features'])
     num_hidden = int(arguments['--hidden'])
     mutation_distance = float(arguments['--mu_distance'])
-    param_args = [num_features, num_hidden, mutation_rate, mutation_distance]
+    param_kwargs = {"num_features": num_features, 
+                  "num_hidden": num_hidden, 
+                  "mutation_distance": mutation_distance}
 
     objective = prepare_objective(name, turns, noise, repetitions, nmoran)
-    population = Population(ANNParams, param_args, population, objective,
-                            output_filename, bottleneck, processes=processes)
+    population = Population(ANNParams, param_kwargs, population, objective,
+                            output_filename, bottleneck, 
+                            mutation_probability,
+                            processes=processes)
     population.run(generations)

bin/fsm_evolve.py

@@ -36,7 +36,7 @@
 
     # Vars for the genetic algorithm
     population = int(arguments['--population'])
-    mutation_rate = float(arguments['--mu'])
+    mutation_probability = float(arguments['--mu'])
     generations = int(arguments['--generations'])
     bottleneck = int(arguments['--bottleneck'])
     output_filename = arguments['--output']
@@ -50,9 +50,10 @@
 
     # FSM
     num_states = int(arguments['--states'])
-    param_args = [num_states, mutation_rate]
+    param_kwargs = {"num_states": num_states}
 
     objective = prepare_objective(name, turns, noise, repetitions, nmoran)
-    population = Population(FSMParams, param_args, population, objective,
-                            output_filename, bottleneck, processes=processes)
+    population = Population(FSMParams, param_kwargs, population, objective,
+                            output_filename, bottleneck, mutation_probability,
+                            processes=processes)
     population.run(generations)

bin/hmm_evolve.py

@@ -215,7 +215,7 @@ def parse_matrix(sm):
 
     # Vars for the genetic algorithm
     population = int(arguments['--population'])
-    mutation_rate = float(arguments['--mu'])
+    mutation_probability = float(arguments['--mu'])
     generations = int(arguments['--generations'])
     bottleneck = int(arguments['--bottleneck'])
     output_filename = arguments['--output']
@@ -229,9 +229,11 @@ def parse_matrix(sm):
 
     # FSM
     num_states = int(arguments['--states'])
-    param_args = [num_states, mutation_rate]
+    param_kwargs = {"num_states": num_states}
 
     objective = prepare_objective(name, turns, noise, repetitions, nmoran)
-    population = Population(HMMParams, param_args, population, objective,
-                            output_filename, bottleneck, processes=processes)
+    population = Population(HMMParams, param_kwargs, population, objective,
+                            output_filename, bottleneck,
+                            mutation_probability,
+                            processes=processes)
     population.run(generations)

bin/pso_evolve.py

@@ -54,11 +54,13 @@
     plays = int(arguments['--plays'])
     op_plays = int(arguments['--op_plays'])
     op_start_plays = int(arguments['--op_start_plays'])
-    param_args = [plays, op_plays, op_start_plays]
+    param_kwargs = {"plays": plays,
+                    "op_plays": op_plays,
+                    "op_state_plays": op_start_plays}
 
     objective = prepare_objective(name, turns, noise, repetitions, nmoran)
 
-    pso = PSO(GamblerParams, param_args, objective=objective,
+    pso = PSO(GamblerParams, param_kwargs, objective=objective,
               population=population, generations=generations)
 
     xopt, fopt = pso.swarm()

src/axelrod_dojo/algorithms/genetic_algorithm.py

@@ -11,11 +11,13 @@
 
 class Population(object):
     """Population class that implements the evolutionary algorithm."""
-    def __init__(self, params_class, params_args, size, objective, output_filename,
-                 bottleneck=None, opponents=None, processes=1, weights=None,
+    def __init__(self, params_class, params_kwargs, size, objective, output_filename,
+                 bottleneck=None, mutation_probability=.1, opponents=None,
+                 processes=1, weights=None,
                  sample_count=None, population=None):
         self.params_class = params_class
         self.bottleneck = bottleneck
+
         if processes == 0:
             processes = cpu_count()
         self.pool = Pool(processes=processes)
@@ -33,12 +35,16 @@ def __init__(self, params_class, params_args, size, objective, output_filename,
             self.opponents_information = [
                     PlayerInfo(p.__class__, p.init_kwargs) for p in opponents]
         self.generation = 0
-        self.params_args = params_args
+
+        self.params_kwargs = params_kwargs
+        if "mutation_probability" not in self.params_kwargs:
+            self.params_kwargs["mutation_probability"] = mutation_probability
 
         if population is not None:
             self.population = population
         else:
-            self.population = [params_class(*params_args) for _ in range(self.size)]
+            self.population = [params_class(**params_kwargs)
+                               for _ in range(self.size)]
 
         self.weights = weights
         self.sample_count = sample_count
@@ -95,7 +101,7 @@ def evolve(self):
             p.mutate()
             self.population.append(p)
         # Add random variants
-        random_params = [self.params_class(*self.params_args)
+        random_params = [self.params_class(**self.params_kwargs)
                          for _ in range(self.bottleneck // 2)]
         params_to_modify = [params.copy() for params in self.population]
         params_to_modify += random_params

src/axelrod_dojo/algorithms/particle_swarm_optimization.py

@@ -8,12 +8,12 @@
 
 class PSO(object):
     """PSO class that implements a particle swarm optimization algorithm."""
-    def __init__(self, params_class, params_args, objective, opponents=None,
+    def __init__(self, params_class, params_kwargs, objective, opponents=None,
                  population=1, generations=1, debug=True, phip=0.8, phig=0.8,
                  omega=0.8, weights=None, sample_count=None, processes=1):
 
         self.params_class = params_class
-        self.params_args = params_args
+        self.params_kwargs = params_kwargs
         self.objective = objective
         if opponents is None:
             self.opponents_information = [
@@ -36,7 +36,7 @@ def __init__(self, params_class, params_args, objective, opponents=None,
 
     def swarm(self):
 
-        params = self.params_class(*self.params_args)
+        params = self.params_class(**self.params_kwargs)
         lb, ub = params.create_vector_bounds()
 
         def objective_function(vector):

src/axelrod_dojo/archetypes/fsm.py

@@ -18,14 +18,12 @@ def copy_lists(rows):
 
 class FSMParams(Params):
 
-    def __init__(self, num_states, mutation_rate=None, rows=None,
-                 initial_state=0, initial_action=C):
+    def __init__(self, num_states, rows=None,
+                 initial_state=0, initial_action=C,
+                 mutation_probability=0):
         self.PlayerClass = FSMPlayer
         self.num_states = num_states
-        if mutation_rate is None:
-            self.mutation_rate = 1 / (2 * num_states)
-        else:
-            self.mutation_rate = mutation_rate
+        self.mutation_probability = mutation_probability
         if rows is None:
             self.randomize()
         else:
@@ -40,8 +38,8 @@ def player(self):
         return player
 
     def copy(self):
-        return FSMParams(self.num_states, self.mutation_rate,
-                         self.rows, self.initial_state, self.initial_action)
+        return FSMParams(self.num_states, self.rows,
+                         self.initial_state, self.initial_action)
 
     @staticmethod
     def random_params(num_states):
@@ -64,11 +62,11 @@ def randomize(self):
         self.initial_action = initial_action
 
     @staticmethod
-    def mutate_rows(rows, mutation_rate):
+    def mutate_rows(rows, mutation_probability):
         randoms = np.random.random(len(rows))
         # Flip each value with a probability proportional to the mutation rate
         for i, row in enumerate(rows):
-            if randoms[i] < mutation_rate:
+            if randoms[i] < mutation_probability:
                 row[3] = row[3].flip()
         # Swap Two Nodes?
         if random.random() < 0.5:
@@ -83,10 +81,10 @@ def mutate_rows(rows, mutation_rate):
         return rows
 
     def mutate(self):
-        self.rows = self.mutate_rows(self.rows, self.mutation_rate)
-        if random.random() < self.mutation_rate / 10:
+        self.rows = self.mutate_rows(self.rows, self.mutation_probability)
+        if random.random() < self.mutation_probability:
             self.initial_action = self.initial_action.flip()
-        if random.random() < self.mutation_rate / (10 * self.num_states):
+        if random.random() < self.mutation_probability / self.num_states:
             self.initial_state = randrange(self.num_states)
         # Change node size?
 
@@ -101,8 +99,11 @@ def crossover_rows(rows1, rows2):
     def crossover(self, other):
         # Assuming that the number of states is the same
         new_rows = self.crossover_rows(self.rows, other.rows)
-        return FSMParams(self.num_states, self.mutation_rate, new_rows,
-                         self.initial_state, self.initial_action)
+        return FSMParams(num_states=self.num_states, 
+                         mutation_probability=self.mutation_probability, 
+                         rows=new_rows,
+                         initial_state=self.initial_state, 
+                         initial_action=self.initial_action)
 
     @staticmethod
     def repr_rows(rows):
@@ -136,7 +137,7 @@ def parse_repr(cls, s):
 
             rows.append(row)
         num_states = len(rows) // 2
-        return cls(num_states, 0.1, rows, initial_state, initial_action)
+        return cls(num_states, rows, initial_state, initial_action)
 
     def receive_vector(self, vector):
         """Receives a vector and creates an instance attribute called
@@ -145,13 +146,13 @@ def receive_vector(self, vector):
 
     def vector_to_instance(self):
         """Turns the attribute vector in to a FSM player instance.
-         
+
         The vector has three parts. The first is used to define the next state 
         (for each of the player's states - for each opponents action).
-         
+
         The second part is the player's next moves (for each state - for 
         each opponent's actions).
-        
+
         Finally, a probability to determine the player's first move."""
 
         num_states = int((len(self.vector) - 1) / 4)
@@ -175,4 +176,4 @@ def create_vector_bounds(self):
         lb = [0] * size
         ub = [1] * size
 
-        return lb, ub
+        return lb, ub

tests/algorithms/test_particle_swarm_optimization.py

@@ -59,7 +59,9 @@ def test_pso_with_gambler(self):
         num_plays = 1
         num_op_plays = 1
         num_op_start_plays = 1
-        params_args = [num_plays, num_op_plays, num_op_start_plays]
+        params_kwargs = {"plays": num_plays,
+                         "op_plays": num_op_plays,
+                         "op_start_plays": num_op_start_plays}
         population = 10
         generations = 100
         opponents = [axl.Cooperator() for _ in range(5)]
@@ -69,7 +71,7 @@ def test_pso_with_gambler(self):
                                            noise=noise,
                                            repetitions=repetitions)
 
-        pso = PSO(GamblerParams, params_args, objective=objective, debug=False,
+        pso = PSO(GamblerParams, params_kwargs, objective=objective, debug=False,
                   opponents=opponents, population=population, generations=generations)
 
         axl.seed(0)
@@ -90,7 +92,7 @@ def test_pso_with_fsm(self):
         noise = 0
         repetitions = 5
         num_states = 4
-        params_args = [num_states]
+        params_kwargs = {"num_states": num_states}
         population = 10
         generations = 100
         opponents = [axl.Defector() for _ in range(5)]
@@ -100,7 +102,7 @@ def test_pso_with_fsm(self):
                                            noise=noise,
                                            repetitions=repetitions)
 
-        pso = PSO(FSMParams, params_args, objective=objective, debug=False,
+        pso = PSO(FSMParams, params_kwargs, objective=objective, debug=False,
                   opponents=opponents, population=population, generations=generations)
 
         axl.seed(0)

tests/archetypes/test_fsm.py

@@ -14,7 +14,6 @@ def test_init(self):
         fsm_params = FSMParams(num_states=num_states, rows=rows)
         self.assertEqual(fsm_params.PlayerClass, axl.FSMPlayer)
         self.assertEqual(fsm_params.num_states, num_states)
-        self.assertEqual(fsm_params.mutation_rate, 1 / (2 * num_states))
         self.assertEqual(fsm_params.rows, rows)
         self.assertEqual(fsm_params.initial_action, C)
         self.assertEqual(fsm_params.initial_state, 0)
@@ -48,8 +47,6 @@ def test_copy(self):
         # Have same attributes
         self.assertEqual(fsm_params.PlayerClass, copy_fsm_params.PlayerClass)
         self.assertEqual(fsm_params.num_states, copy_fsm_params.num_states)
-        self.assertEqual(fsm_params.mutation_rate,
-                         copy_fsm_params.mutation_rate)
         self.assertEqual(fsm_params.rows, copy_fsm_params.rows)
         self.assertEqual(fsm_params.initial_action,
                          copy_fsm_params.initial_action)
@@ -113,8 +110,6 @@ def test_crossover(self):
 
         self.assertEqual(fsm_params.PlayerClass, fsm_params1.PlayerClass)
         self.assertEqual(fsm_params.num_states, fsm_params1.num_states)
-        self.assertEqual(fsm_params.mutation_rate,
-                         fsm_params1.mutation_rate)
         self.assertEqual(fsm_params.initial_action,
                          fsm_params1.initial_action)
         self.assertEqual(fsm_params.initial_state,