Add weights to objective (#28)

* Use numpy average in score_params.

This is with a view to use the weights so that we can weight scoring
according to weights for each opponent.
(Mainly to be able to use the regression model type work in Axelrod's
second paper.)

* Write tests for weights in utils.score_params.

* Add ability to weight opponents.

This is with a view to use the coefficients from the regression analysis
in the training.

* Remove tqdm

Author: drvinceknight

requirements.txt

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

src/axelrod_dojo/utils.py

@@ -7,6 +7,7 @@
 import csv
 import os
 
+import numpy as np
 import axelrod as axl
 
 
@@ -130,7 +131,7 @@ def crossover(self, other):
         pass
 
 
-def score_params(params, objective, opponents):
+def score_params(params, objective, opponents, weights=None):
     """
     Return the overall mean score of a Params instance.
     """
@@ -144,14 +145,15 @@ def score_params(params, objective, opponents):
         mean_vs_opponent = mean(scores_for_this_opponent)
         scores_for_all_opponents.append(mean_vs_opponent)
 
-    overall_mean_score = mean(scores_for_all_opponents)
+    overall_mean_score = np.average(scores_for_all_opponents,
+                                    weights=weights)
     return overall_mean_score
 
 
 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):
+                 bottleneck=None, opponents=None, processes=1, weights=None):
         self.params_class = params_class
         self.bottleneck = bottleneck
         self.pool = Pool(processes=processes)
@@ -169,12 +171,14 @@ def __init__(self, params_class, params_args, size, objective, output_filename,
         self.generation = 0
         self.params_args = params_args
         self.population = [params_class(*params_args) for _ in range(self.size)]
+        self.weights = weights
 
     def score_all(self):
         starmap_params = zip(
             self.population,
             repeat(self.objective),
-            repeat(self.opponents))
+            repeat(self.opponents),
+            repeat(self.weights))
         results = self.pool.starmap(score_params, starmap_params)
         return results
 

tests/integration/test_fsm.py

@@ -60,3 +60,55 @@ def test_score(self):
                 self.assertIsInstance(parameters, dojo.FSMParams)
 
             self.assertEqual(best[0].__repr__(), best_params)
+
+    def test_score_with_weights(self):
+        name = "score"
+        turns = 10
+        noise = 0
+        repetitions = 5
+        num_states = 2
+        mutation_rate = .1
+        opponents = axl.demo_strategies
+        size = 10
+
+        objective = dojo.prepare_objective(name=name,
+                                           turns=turns,
+                                           noise=noise,
+                                           repetitions=repetitions)
+
+        population = dojo.Population(params_class=dojo.FSMParams,
+                                     params_args=(num_states, mutation_rate),
+                                     size=size,
+                                     objective=objective,
+                                     output_filename=self.temporary_file.name,
+                                     opponents=opponents,
+                                     weights=[5, 1, 1, 1, 1],
+                                     bottleneck=2,
+                                     processes=1)
+
+        generations = 4
+        axl.seed(0)
+        population.run(generations)
+        self.assertEqual(population.generation, 4)
+
+        # Manually read from tempo file to find best strategy
+        best_score, best_params = 0, None
+        with open(self.temporary_file.name, "r") as f:
+            reader = csv.reader(f)
+            for row in reader:
+                _, mean_score, sd_score, max_score, arg_max = row
+                if float(max_score) > best_score:
+                    best_score = float(max_score)
+                    best_params = arg_max
+
+        # Test the load params function
+        for num in range(1, 4 + 1):
+            best = dojo.load_params(params_class=dojo.FSMParams,
+                                    filename=self.temporary_file.name,
+                                    num=num)
+            self.assertEqual(len(best), num)
+
+            for parameters in best:
+                self.assertIsInstance(parameters, dojo.FSMParams)
+
+            self.assertEqual(best[0].__repr__(), best_params)

tests/unit/test_utils.py

@@ -190,3 +190,32 @@ def test_score(self):
                                    opponents=opponents)
         expected_score = 2.0949
         self.assertEqual(score, expected_score)
+
+    def test_score_with_weights(self):
+        axl.seed(0)
+        opponents = axl.demo_strategies
+        objective = utils.prepare_objective()
+        params = DummyParams()
+        score = utils.score_params(params,
+                                   objective=objective,
+                                   opponents=opponents,
+                                   # All weight on Coop
+                                   weights=[1, 0, 0, 0, 0])
+        expected_score = 3
+        self.assertEqual(score, expected_score)
+
+        score = utils.score_params(params,
+                                   objective=objective,
+                                   opponents=opponents,
+                                   # Shared weight between Coop and Def
+                                   weights=[2, 2, 0, 0, 0])
+        expected_score = 1.5
+        self.assertEqual(score, expected_score)
+
+        score = utils.score_params(params,
+                                   objective=objective,
+                                   opponents=opponents,
+                                   # Shared weight between Coop and Def
+                                   weights=[2, -.5, 0, 0, 0])
+        expected_score = 4.0
+        self.assertEqual(score, expected_score)