Refactor to allow for different algorithms to work on different archetypes (#36)

* create src/dojo/algorithms.

Moved te ganetic algorithm class in here.

Fix the imports.

(some files to my gitignore and some pep8)

* create gambler archetype and pso algorithm.

The pso_evolve script was modified and the functions have been
moved into src/axelrod-dogo/archetype/gambler.

The pso algorithm has been implemented as an algorithm and
is in src/axelrod-dojo/algorithms/particle_swarm_optimization.

Also remove the ability for multiprocessing pso. There
is an error that our objective function can not be pickeled.

(fixed some pep8)

* implement pso algorithm for fsm archetype

* add multiprocessing for pso algorithm.

Add the check for the pyswarm version as well.
I did open an issue but the github account doesn't look
active anymore.

also fix some pep8

* move scripts to bin.

* docstring for the new functions.

* made minor corrections.

Comments by Marc.

Author: Nikoleta-v3

.gitignore

@@ -58,3 +58,6 @@ target/
 data/
 
 *.mypy*
+
+# pycharm
+.idea/

analyze_data.py renamed to bin/analyze_data.py

@@ -7,7 +7,7 @@
 
 Usage:
     pso_evolve.py [-h] [--generations GENERATIONS] [--population POPULATION]
-    [--processes PROCESSORS] [--output OUTPUT_FILE] [--objective OBJECTIVE]
+    [--output OUTPUT_FILE] [--objective OBJECTIVE]
     [--repetitions REPETITIONS] [--turns TURNS] [--noise NOISE]
     [--nmoran NMORAN]
     [--plays PLAYS] [--op_plays OP_PLAYS] [--op_start_plays OP_START_PLAYS]
@@ -16,7 +16,6 @@
     -h --help                   Show help
     --generations GENERATIONS   Generations to run the EA [default: 100]
     --population POPULATION     Starting population size  [default: 40]
-    --processes PROCESSES       Number of processes to use [default: 1]
     --output OUTPUT_FILE        File to write data to [default: pso_tables.csv]
     --objective OBJECTIVE       Objective function [default: score]
     --repetitions REPETITIONS   Repetitions in objective [default: 100]
@@ -29,28 +28,16 @@
 """
 
 from docopt import docopt
-import pyswarm
 
-from axelrod import Gambler
-from axelrod.strategies.lookerup import (
-    create_lookup_table_keys, Plays)
-from axelrod_dojo import prepare_objective, score_for
+from axelrod_dojo.archetypes.gambler import GamblerParams
+from axelrod_dojo.algorithms.particle_swarm_optimization import PSO
 
 
-def optimizepso(param_args, objective, opponents=None):
-    def f(pattern):
-        self_plays, op_plays, op_openings = param_args
-        params = Plays(self_plays=self_plays, op_plays=op_plays,
-                       op_openings=op_openings)
-        return -score_for(Gambler, objective,
-                          args=[None, None, pattern, params],
-                          opponents=opponents)
-    return f
+from axelrod_dojo.utils import prepare_objective
 
 if __name__ == "__main__":
     arguments = docopt(__doc__, version='PSO Evolve 0.3')
     print(arguments)
-    processes = int(arguments['--processes'])
 
     # Population Args
     population = int(arguments['--population'])
@@ -71,22 +58,10 @@ def f(pattern):
 
     objective = prepare_objective(name, turns, noise, repetitions, nmoran)
 
-    size = len(create_lookup_table_keys(plays, op_plays, op_start_plays))
-    lb = [0] * size
-    ub = [1] * size
+    pso = PSO(GamblerParams, param_args, objective=objective,
+              population=population, generations=generations)
 
-    optimizer = optimizepso(param_args, objective)
+    xopt, fopt = pso.swarm()
 
-    # There is a multiprocessing version (0.7) of pyswarm available at
-    # https://github.com/tisimst/pyswarm, just pass processes=X
-    # Pip installs version 0.6
-    if pyswarm.__version__ == "0.7":
-        xopt, fopt = pyswarm.pso(
-            optimizer, lb, ub, swarmsize=population, maxiter=generations,
-            debug=True, phip=0.8, phig=0.8, omega=0.8, processes=processes)
-    else:
-        xopt, fopt = pyswarm.pso(
-            optimizer, lb, ub, swarmsize=population, maxiter=generations,
-            debug=True, phip=0.8, phig=0.8, omega=0.8)
     print(xopt)
     print(fopt)

ann_evolve.py renamed to bin/ann_evolve.py

@@ -1,8 +1,9 @@
 from .version import __version__
 from .archetypes.fsm import FSMParams
+from .archetypes.gambler import GamblerParams
+from .algorithms.genetic_algorithm import Population
 from .utils import (prepare_objective,
-                    Population,
                     load_params,
                     Params,
-                    score_for,
                     PlayerInfo)
+

fsm_evolve.py renamed to bin/fsm_evolve.py

@@ -0,0 +1,119 @@
+from itertools import repeat
+from multiprocessing import Pool, cpu_count
+from operator import itemgetter
+from random import randrange
+from statistics import mean, pstdev
+
+import axelrod as axl
+
+from axelrod_dojo.utils import Outputer, PlayerInfo, score_params
+
+
+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,
+                 sample_count=None, population=None):
+        self.params_class = params_class
+        self.bottleneck = bottleneck
+        if processes == 0:
+            processes = cpu_count()
+        self.pool = Pool(processes=processes)
+        self.outputer = Outputer(output_filename, mode='a')
+        self.size = size
+        self.objective = objective
+        if not bottleneck:
+            self.bottleneck = size // 4
+        else:
+            self.bottleneck = bottleneck
+        if opponents is None:
+            self.opponents_information = [
+                    PlayerInfo(s, {}) for s in axl.short_run_time_strategies]
+        else:
+            self.opponents_information = [
+                    PlayerInfo(p.__class__, p.init_kwargs) for p in opponents]
+        self.generation = 0
+        self.params_args = params_args
+
+        if population is not None:
+            self.population = population
+        else:
+            self.population = [params_class(*params_args) for _ in range(self.size)]
+
+        self.weights = weights
+        self.sample_count = sample_count
+
+    def score_all(self):
+        starmap_params = zip(
+            self.population,
+            repeat(self.objective),
+            repeat(self.opponents_information),
+            repeat(self.weights),
+            repeat(self.sample_count))
+        results = self.pool.starmap(score_params, starmap_params)
+        return results
+
+    def subset_population(self, indices):
+        population = []
+        for i in indices:
+            population.append(self.population[i])
+        self.population = population
+
+    @staticmethod
+    def crossover(population, num_variants):
+        new_variants = []
+        for _ in range(num_variants):
+            i = randrange(len(population))
+            j = randrange(len(population))
+            new_variant = population[i].crossover(population[j])
+            new_variants.append(new_variant)
+        return new_variants
+
+    def evolve(self):
+        self.generation += 1
+        print("Scoring Generation {}".format(self.generation))
+
+        # Score population
+        scores = self.score_all()
+        results = list(zip(scores, range(len(scores))))
+        results.sort(key=itemgetter(0), reverse=True)
+
+        # Report
+        print("Generation", self.generation, "| Best Score:", results[0][0],
+              repr(self.population[results[0][1]]))
+        # Write the data
+        row = [self.generation, mean(scores), pstdev(scores), results[0][0],
+               repr(self.population[results[0][1]])]
+        self.outputer.write(row)
+
+        ## Next Population
+        indices_to_keep = [p for (s, p) in results[0: self.bottleneck]]
+        self.subset_population(indices_to_keep)
+        # Add mutants of the best players
+        best_mutants = [p.copy() for p in self.population]
+        for p in best_mutants:
+            p.mutate()
+            self.population.append(p)
+        # Add random variants
+        random_params = [self.params_class(*self.params_args)
+                         for _ in range(self.bottleneck // 2)]
+        params_to_modify = [params.copy() for params in self.population]
+        params_to_modify += random_params
+        # Crossover
+        size_left = self.size - len(params_to_modify)
+        params_to_modify = self.crossover(params_to_modify, size_left)
+        # Mutate
+        for p in params_to_modify:
+            p.mutate()
+        self.population += params_to_modify
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        self.evolve()
+
+    def run(self, generations):
+        for _ in range(generations):
+            next(self)
+        self.outputer.close()

hmm_evolve.py renamed to bin/hmm_evolve.py

@@ -0,0 +1,69 @@
+import axelrod as axl
+import pyswarm
+
+from axelrod_dojo.utils import score_params
+from axelrod_dojo.utils import PlayerInfo
+from multiprocessing import cpu_count
+
+
+class PSO(object):
+    """PSO class that implements a particle swarm optimization algorithm."""
+    def __init__(self, params_class, params_args, 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.objective = objective
+        if opponents is None:
+            self.opponents_information = [
+                    PlayerInfo(s, {}) for s in axl.short_run_time_strategies]
+        else:
+            self.opponents_information = [
+                    PlayerInfo(p.__class__, p.init_kwargs) for p in opponents]
+        self.population = population
+        self.generations = generations
+        self.debug = debug
+        self.phip = phip
+        self.phig = phig
+        self.omega = omega
+        self.weights = weights
+        self.sample_count = sample_count
+        if processes == 0:
+            self.processes = cpu_count()
+        else:
+            self.processes = processes
+
+    def swarm(self):
+
+        params = self.params_class(*self.params_args)
+        lb, ub = params.create_vector_bounds()
+
+        def objective_function(vector):
+            params.receive_vector(vector=vector)
+            instance_generation_function = 'vector_to_instance'
+
+            return - score_params(params=params, objective=self.objective,
+                                  opponents_information=self.opponents_information,
+                                  weights=self.weights,
+                                  sample_count=self.sample_count,
+                                  instance_generation_function=instance_generation_function
+                                 )
+
+        # TODO remove check once v 0.7 is pip installable
+        # There is a multiprocessing version (0.7) of pyswarm available at
+        # https://github.com/tisimst/pyswarm, just pass processes=X
+        # Pip installs version 0.6
+        if pyswarm.__version__ == "0.7":
+            xopt, fopt = pyswarm.pso(objective_function, lb, ub,
+                                     swarmsize=self.population,
+                                     maxiter=self.generations, debug=self.debug,
+                                     phip=self.phip, phig=self.phig,
+                                     omega=self.omega, processes=self.processes)
+        else:
+            xopt, fopt = pyswarm.pso(objective_function, lb, ub,
+                                     swarmsize=self.population,
+                                     maxiter=self.generations, debug=self.debug,
+                                     phip=self.phip, phig=self.phig,
+                                     omega=self.omega)
+        return xopt, fopt

lookup_evolve.py renamed to bin/lookup_evolve.py

@@ -1,11 +1,12 @@
 import random
+import itertools
 from random import randrange, choice
 
 import numpy as np
 from axelrod import Action, FSMPlayer
 from axelrod.action import UnknownActionError
 
-from axelrod_dojo.utils import Params, Population, prepare_objective
+from axelrod_dojo.utils import Params
 
 C, D = Action.C, Action.D
 
@@ -33,7 +34,6 @@ def __init__(self, num_states, mutation_rate=None, rows=None,
         self.initial_state = initial_state
         self.initial_action = initial_action
 
-
     def player(self):
         player = self.PlayerClass(self.rows, self.initial_state,
                                   self.initial_action)
@@ -137,3 +137,42 @@ def parse_repr(cls, s):
             rows.append(row)
         num_states = len(rows) // 2
         return cls(num_states, 0.1, rows, initial_state, initial_action)
+
+    def receive_vector(self, vector):
+        """Receives a vector and creates an instance attribute called
+        vector."""
+        self.vector = 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)
+        state_scale = self.vector[:num_states * 2]
+        next_states = [int(s * (num_states - 1)) for s in state_scale]
+        actions = self.vector[num_states * 2: -1]
+        starting_move = C if round(self.vector[-1]) == 0 else D
+
+        fsm = []
+        for i, (initial_state, action) in enumerate(
+                itertools.product(range(num_states), [C, D])):
+            next_action = C if round(actions[i]) == 0 else D
+            fsm.append([initial_state, action, next_states[i], next_action])
+
+        return FSMPlayer(fsm, initial_action=starting_move)
+
+    def create_vector_bounds(self):
+        """Creates the bounds for the decision variables."""
+        size = len(self.rows) * 2 + 1
+
+        lb = [0] * size
+        ub = [1] * size
+
+        return lb, ub