Packaging (#27)

* Add a lower bound to requirements.txt

* Write setup.py and restructure.

* Write tests for outputer.

* Tests written for prepare objective.

* Tests for the objective score function.

* Write tests for score diff.

* Write tests and fix a bug for Moran objective.

* Write tests for base parameters class.

* Add tests for score_params.

* Add mypy to gigignore

I have no idea what generated these files.

* Move the fsm params class.

Very slight modification of the repr parser.

* Make tests discoverable.

* Write an integration test for the FSM.

* Make scripts work with library.

* Minor clean up of README.md

* Add CI.

* Correct path for tests.

* Fix coverage path.

* Add another seed in the integration test.

* Add instructions to run tests.

Author: drvinceknight

.gitignore

@@ -56,3 +56,5 @@ docs/_build/
 # PyBuilder
 target/
 data/
+
+*.mypy*

.travis.yml

@@ -0,0 +1,19 @@
+language: python
+python:
+  - 3.5
+  - 3.6
+
+
+before_install:
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start
+install:
+  - pip install -r requirements.txt
+  - pip install coverage
+  - pip install coveralls
+script:
+  - python setup.py develop
+  - coverage run --source=src -m unittest discover tests
+  - coverage report -m
+after_success:
+  - coveralls

README.md

@@ -1,7 +1,10 @@
 # Axelrod Evolvers
 
+
+
 This repository contains reinforcement learning training code for the following
 strategy types:
+
 * Lookup tables (LookerUp)
 * Particle Swarm algorithms (PSOGambler), a stochastic version of LookerUp
 * Feed Forward Neural Network (EvolvedANN)
@@ -10,9 +13,25 @@ strategy types:
 
 Model training is by [evolutionary algorithms](https://en.wikipedia.org/wiki/Evolutionary_algorithm)
  or [particle swarm algorithms](https://en.wikipedia.org/wiki/Particle_swarm_optimization).
-There is another repository in the [Axerlod project](https://github.com/Axelrod-Python/Axelrod)
+There is another repository in the [Axelrod project](https://github.com/Axelrod-Python/Axelrod)
 that trains Neural Networks with gradient descent (using tensorflow)
-that will likely be incorporated here. In this repository there are scripts
+that will likely be incorporated here.
+
+You can use this as a library.
+
+## Development
+
+Install a development version of the library:
+
+    $ python setup.py develop
+
+Run the test:
+
+    $ python -m unittest discover tests
+
+## Scripts
+
+In this repository there are scripts
 for each strategy type with a similar interface:
 
 * [looker_evolve.py](looker_evolve.py)
@@ -21,6 +40,7 @@ for each strategy type with a similar interface:
 * [fsm_evolve.py](fsm_evolve.py)
 * [hmm_evolve.py](hmm_evolve.py)
 
+
 See below for usage instructions.
 
 In the original iteration the strategies were run against all the default

ann_evolve.py

@@ -33,13 +33,12 @@
 import random
 
 from docopt import docopt
-import numpy as np
 
-from axelrod import Actions
+from axelrod import Action
 from axelrod.strategies.ann import ANN
-from evolve_utils import Params, Population, prepare_objective
+from axelrod_dojo import Params, Population, prepare_objective
 
-C, D = Actions.C, Actions.D
+C, D = Action.C, Action.D
 
 
 ## Todo: mutation decay

fsm_evolve.py

@@ -24,140 +24,9 @@
     --states NUM_STATES         Number of FSM states [default: 8]
 """
 
-import random
-from random import randrange, choice
-
 from docopt import docopt
-import numpy as np
-
-from axelrod import Actions, flip_action
-from axelrod.strategies.finite_state_machines import FSMPlayer
-
-from evolve_utils import Params, Population, prepare_objective
-
-C, D = Actions.C, Actions.D
-
-
-def copy_lists(rows):
-    new_rows = list(map(list, rows))
-    return new_rows
-
-
-class FSMParams(Params):
-
-    def __init__(self, num_states, mutation_rate=None, rows=None,
-                 initial_state=0, initial_action=C):
-        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
-        if rows is None:
-            self.randomize()
-        else:
-            # Make sure to copy the lists
-            self.rows = copy_lists(rows)
-        self.initial_state = initial_state
-        self.initial_action = initial_action
-
-
-    def player(self):
-        player = self.PlayerClass(self.rows, self.initial_state,
-                                  self.initial_action)
-        return player
-
-    def copy(self):
-        return FSMParams(self.num_states, self.mutation_rate,
-                         self.rows, self.initial_state, self.initial_action)
-
-    @staticmethod
-    def random_params(num_states):
-        rows = []
-        actions = (C, D)
-        for j in range(num_states):
-            for action in actions:
-                next_state = randrange(num_states)
-                next_action = choice(actions)
-                row = [j, action, next_state, next_action]
-                rows.append(row)
-        initial_state = randrange(num_states)
-        initial_action = choice([C, D])
-        return rows, initial_state, initial_action
-
-    def randomize(self):
-        rows, initial_state, initial_action = self.random_params(self.num_states)
-        self.rows = rows
-        self.initial_state = initial_state
-        self.initial_action = initial_action
-
-    @staticmethod
-    def mutate_rows(rows, mutation_rate):
-        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:
-                row[3] = flip_action(row[3])
-        # Swap Two Nodes?
-        if random.random() < 0.5:
-            nodes = len(rows) // 2
-            n1 = randrange(nodes)
-            n2 = randrange(nodes)
-            for j, row in enumerate(rows):
-                if row[1] == n1:
-                    row[1] = n2
-                elif row[1] == n2:
-                    row[1] = n1
-        return rows
-
-    def mutate(self):
-        self.rows = self.mutate_rows(self.rows, self.mutation_rate)
-        if random.random() < self.mutation_rate / 10:
-            self.initial_action = flip_action(self.initial_action)
-        if random.random() < self.mutation_rate / (10 * self.num_states):
-            self.initial_state = randrange(self.num_states)
-        # Change node size?
-
-    @staticmethod
-    def crossover_rows(rows1, rows2):
-        num_states = len(rows1) // 2
-        crosspoint = 2 * randrange(num_states)
-        new_rows = copy_lists(rows1[:crosspoint])
-        new_rows += copy_lists(rows2[crosspoint:])
-        return new_rows
-
-    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)
-
-    @staticmethod
-    def repr_rows(rows):
-        ss = []
-        for row in rows:
-            ss.append("_".join(list(map(str, row))))
-        return ":".join(ss)
-
-    def __repr__(self):
-        return "{}:{}:{}".format(
-            self.initial_state,
-            self.initial_action,
-            self.repr_rows(self.rows)
-        )
-
-    @classmethod
-    def parse_repr(cls, s):
-        rows = []
-        lines = s.split(':')
-        initial_state = int(lines[0])
-        initial_action = lines[1]
 
-        for line in lines[2:]:
-            row = line.split('_')
-            rows.append(row)
-        num_states = len(rows) // 2
-        return cls(num_states, 0.1, rows, initial_state, initial_action)
+from axelrod_dojo import FSMParams, Population, prepare_objective
 
 
 if __name__ == '__main__':

hmm_evolve.py

@@ -35,12 +35,11 @@
 from docopt import docopt
 import numpy as np
 
-from axelrod import Actions, flip_action
+from axelrod import Action
 from axelrod.strategies.hmm import HMMPlayer
+from axelrod_dojo import Params, Population, prepare_objective
 
-from evolve_utils import Params, Population, prepare_objective
-
-C, D = Actions.C, Actions.D
+C, D = Action.C, Action.D
 
 
 def copy_lists(rows):
@@ -145,7 +144,7 @@ def mutate(self):
         self.emission_probabilities = mutate_row(
             self.emission_probabilities, self.mutation_rate)
         if random.random() < self.mutation_rate / 10:
-            self.initial_action = flip_action(self.initial_action)
+            self.initial_action = self.initial_action.flip()
         if random.random() < self.mutation_rate / (10 * self.num_states):
             self.initial_state = randrange(self.num_states)
         # Change node size?

lookup_evolve.py

@@ -31,12 +31,11 @@
 from docopt import docopt
 import numpy as np
 
-from axelrod import Actions, flip_action
+from axelrod import Action
 from axelrod.strategies.lookerup import LookerUp, create_lookup_table_keys
+from axelrod_dojo import Params, Population, prepare_objective
 
-from evolve_utils import Params, Population, prepare_objective
-
-C, D = Actions.C, Actions.D
+C, D = Action.C, Action.D
 
 
 class LookerUpParams(Params):
@@ -92,7 +91,7 @@ def mutate_table(table, mutation_rate):
         # Flip each value with a probability proportional to the mutation rate
         for i, (history, move) in enumerate(table.items()):
             if randoms[i] < mutation_rate:
-                table[history] = flip_action(move)
+                table[history] = move.flip()
         return table
 
     def mutate(self):
@@ -101,7 +100,7 @@ def mutate(self):
         for i in range(len(self.initial_actions)):
             r = random.random()
             if r < 0.05:
-                self.initial_actions[i] = flip_action(self.initial_actions[i])
+                self.initial_actions[i] = self.initial_actions[i].flip()
 
     @staticmethod
     def crossover_tables(table1, table2):

pso_evolve.py

@@ -34,7 +34,7 @@
 from axelrod import Gambler
 from axelrod.strategies.lookerup import (
     create_lookup_table_keys, Plays)
-from evolve_utils import prepare_objective, score_for
+from axelrod_dojo import prepare_objective, score_for
 
 
 def optimizepso(param_args, objective, opponents=None):

requirements.txt

@@ -1,3 +1,4 @@
-axelrod
-pyswarm
-docopt
+axelrod>=3.3.0
+tqdm>=3.4.0
+pyswarm>=0.6
+docopt>=0.6.2

setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+import unittest
+import doctest
+import os
+
+# Read in the version number
+exec(open('src/axelrod_dojo/version.py', 'r').read())
+
+# Read in the requirements.txt file
+with open('requirements.txt') as f:
+    requirements = []
+    for library in f.read().splitlines():
+        if "docopt" not in library:  # Skip: used only for command line scripts
+            requirements.append(library)
+
+setup(
+    name='axelrod_dojo',
+    version=__version__,
+    install_requires=requirements,
+    author='Marc Harper; Vince Knight; Martin Jones; Georgios Koutsovoulos',
+    packages=find_packages('src'),
+    package_dir={"": "src"},
+    url='',
+    license='The MIT License (MIT)',
+    description='A library to train strategies for the Iterated Prisoners Dilemma',
+    classifiers=[
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3 :: Only',
+        ],
+    python_requires='>=3.0',
+)