Merge pull request #34 from Axelrod-Python/add-ability-to-sample-opponents

Add ability to sample a number of opps

Author: marcharper

src/axelrod_dojo/utils.py

@@ -142,13 +142,19 @@ def crossover(self, other):
 
 def score_params(params, objective,
                  opponents_information,
-                 weights=None):
+                 weights=None, sample_count=None):
     """
     Return the overall mean score of a Params instance.
     """
     scores_for_all_opponents = []
     player = params.player()
 
+    if sample_count is not None:
+        indices = np.random.choice(len(opponents_information), sample_count)
+        opponents_information = [opponents_information[i] for i in indices]
+        if weights is not None:
+            weights = [weights[i] for i in indices]
+
     for strategy, init_kwargs in opponents_information:
         player.reset()
         opponent = strategy(**init_kwargs)
@@ -164,7 +170,8 @@ def score_params(params, objective,
 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):
+                 bottleneck=None, opponents=None, processes=1, weights=None,
+                 sample_count=None):
         self.params_class = params_class
         self.bottleneck = bottleneck
         if processes == 0:
@@ -187,13 +194,15 @@ def __init__(self, params_class, params_args, size, objective, output_filename,
         self.params_args = params_args
         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.weights),
+            repeat(self.sample_count))
         results = self.pool.starmap(score_params, starmap_params)
         return results
 

tests/integration/test_fsm.py

@@ -113,6 +113,112 @@ def test_score_with_weights(self):
 
             self.assertEqual(best[0].__repr__(), best_params)
 
+    def test_score_with_sample_count(self):
+        name = "score"
+        turns = 10
+        noise = 0
+        repetitions = 5
+        num_states = 2
+        mutation_rate = .1
+        opponents = [s() for s in 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,
+                                     sample_count=2,  # Randomly sample 2 opponents at each step
+                                     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)
+
+
+    def test_score_with_sample_count_and_weights(self):
+        name = "score"
+        turns = 10
+        noise = 0
+        repetitions = 5
+        num_states = 2
+        mutation_rate = .1
+        opponents = [s() for s in 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,
+                                     sample_count=2,  # Randomly sample 2 opponents at each step
+                                     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)
+
     def test_score_with_particular_players(self):
         """
         These are players that are known to be difficult to pickle