Rewrite many tests to use new seeding method. Rewrite Evolveable player classes to use new seeding methods.

Author: marcharper

axelrod/__init__.py

@@ -6,14 +6,14 @@
 from axelrod.random_ import Pdf, RandomGenerator, BulkRandomGenerator
 
 # Initialize module level Random
-# This is seeded by the clock / OS entropy pool
+# This is initially seeded by the clock / OS entropy pool
 # It is not used if user specifies seeds everywhere and should only be
-# used internally by the library
+# used internally by the library and in certain tests that need to set
+# its seed.
 _module_random = RandomGenerator()
 
 from axelrod.load_data_ import load_pso_tables, load_weights
 from axelrod import graph
-from axelrod.random_ import Pdf, RandomGenerator, BulkRandomGenerator
 from axelrod.plot import Plot
 from axelrod.game import DefaultGame, Game
 from axelrod.history import History, LimitedHistory

axelrod/_strategy_utils.py

@@ -137,7 +137,7 @@ def _calculate_scores(p1, p2, game):
     return s1, s2
 
 
-def look_ahead(player_1, player_2, game, rounds=10):
+def look_ahead(player1, player2, game, rounds=10):
     """Returns a constant action that maximizes score by looking ahead.
 
     Parameters
@@ -160,8 +160,10 @@ def look_ahead(player_1, player_2, game, rounds=10):
     possible_strategies = {C: Cooperator(), D: Defector()}
     for action, player in possible_strategies.items():
         # Instead of a deepcopy, create a new opponent and replay the history to it.
-        opponent_ = player_2.clone()
-        for h in player_1.history:
+        opponent_ = player2.clone()
+        if opponent_.classifier["stochastic"]:
+            opponent_.set_seed(player2._seed)
+        for h in player1.history:
             _limited_simulate_play(player, opponent_, h)
 
         # Now play forward with the constant strategy.

axelrod/evolvable_player.py

@@ -1,6 +1,6 @@
 import base64
+import copy
 from pickle import dumps, loads
-from random import randrange
 from typing import Dict, List
 from .player import Player
 
@@ -21,6 +21,10 @@ class EvolvablePlayer(Player):
     parent_class = Player
     parent_kwargs = []  # type: List[str]
 
+    def __init__(self, seed=None):
+        super().__init__()
+        self.set_seed(seed=seed)
+
     def overwrite_init_kwargs(self, **kwargs):
         """Use to overwrite parameters for proper cloning and testing."""
         for k, v in kwargs.items():
@@ -32,6 +36,24 @@ def create_new(self, **kwargs):
         init_kwargs.update(kwargs)
         return self.__class__(**init_kwargs)
 
+    # def clone(self):
+    #     """Clones the player without history, reapplying configuration
+    #     parameters as necessary.
+    #
+    #     We're overriding Player.clone to also propagate the seed because EvolvablePlayers
+    #     currently randomize themselves on initialization.
+    #     """
+    #
+    #     # You may be tempted to re-implement using the `copy` module
+    #     # Note that this would require a deepcopy in some cases and there may
+    #     # be significant changes required throughout the library.
+    #     # Consider overriding in special cases only if necessary
+    #     cls = self.__class__
+    #     new_player = cls(**self.init_kwargs, seed=self._seed)
+    #     new_player.match_attributes = copy.copy(self.match_attributes)
+    #     # new_player.set_seed(self._seed)
+    #     return new_player
+
     # Serialization and deserialization. You may overwrite to obtain more human readable serializations
     # but you must overwrite both.
 
@@ -73,15 +95,15 @@ def copy_lists(lists: List[List]) -> List[List]:
     return list(map(list, lists))
 
 
-def crossover_lists(list1: List, list2: List) -> List:
-    cross_point = randrange(len(list1))
+def crossover_lists(list1: List, list2: List, rng) -> List:
+    cross_point = rng.randint(0, len(list1))
     new_list = list(list1[:cross_point]) + list(list2[cross_point:])
     return new_list
 
 
-def crossover_dictionaries(table1: Dict, table2: Dict) -> Dict:
+def crossover_dictionaries(table1: Dict, table2: Dict, rng) -> Dict:
     keys = list(table1.keys())
-    cross_point = randrange(len(keys))
+    cross_point = rng.randint(0, len(keys))
     new_items = [(k, table1[k]) for k in keys[:cross_point]]
     new_items += [(k, table2[k]) for k in keys[cross_point:]]
     new_table = dict(new_items)

axelrod/fingerprint.py

@@ -245,7 +245,6 @@ def _construct_tournament_elements(
         progress_bar : bool
             Whether or not to create a progress bar which will be updated
 
-
         Returns
         ----------
         edges : list of tuples
@@ -279,6 +278,7 @@ def fingerprint(
         processes: int = None,
         filename: str = None,
         progress_bar: bool = True,
+        seed: int = None
     ) -> dict:
         """Build and play the spatial tournament.
 
@@ -322,7 +322,8 @@ def fingerprint(
 
         self.step = step
         self.spatial_tournament = axl.Tournament(
-            tourn_players, turns=turns, repetitions=repetitions, edges=edges
+            tourn_players, turns=turns, repetitions=repetitions, edges=edges,
+            seed=seed
         )
         self.spatial_tournament.play(
             build_results=False,

axelrod/match.py

@@ -70,6 +70,7 @@ def __init__(
         self.noise = noise
 
         self.seed = seed
+        self._random = RandomGenerator(seed=self.seed)
 
         if game is None:
             self.game = Game()
@@ -166,8 +167,6 @@ def play(self):
 
         i.e. One entry per turn containing a pair of actions.
         """
-        # if self._stochastic:
-        self._random = RandomGenerator(seed=self.seed)
         if self.prob_end:
             r = self._random.random()
             turns = min(sample_length(self.prob_end, r), self.turns)
@@ -182,6 +181,7 @@ def play(self):
                 p.set_match_attributes(**self.match_attributes)
                 # if p.classifier["stochastic"]:
                 # Generate a random seed for the player
+                # TODO: Seeds only for stochastic players
                 p.set_seed(self._random.random_seed_int())
             result = []
             for _ in range(turns):

axelrod/match_generator.py

@@ -38,6 +38,7 @@ def __init__(
             Mapping attribute names to values which should be passed to players.
             The default is to use the correct values for turns, game and noise
             but these can be overridden if desired.
+        seed : int
         """
         self.players = players
         self.turns = turns

axelrod/moran.py

@@ -10,7 +10,7 @@
 from .deterministic_cache import DeterministicCache
 from .graph import Graph, complete_graph
 from .match import Match
-from .random_ import RandomGenerator
+from .random_ import RandomGenerator, BulkRandomGenerator
 
 
 class MoranProcess(object):
@@ -101,6 +101,7 @@ def __init__(
         self.mutation_rate = mutation_rate
         self.stop_on_fixation = stop_on_fixation
         self._random = RandomGenerator(seed=seed)
+        self._bulk_random = BulkRandomGenerator(self._random.random_seed_int())
         m = mutation_method.lower()
         if m in ["atomic", "transition"]:
             self.mutation_method = m
@@ -249,13 +250,13 @@ def birth(self, index: int = None) -> int:
             # possible choices
             scores.pop(index)
             # Make sure to get the correct index post-pop
-            j = fitness_proportionate_selection(
+            j = self.fitness_proportionate_selection(
                 scores, fitness_transformation=self.fitness_transformation
             )
             if j >= index:
                 j += 1
         else:
-            j = fitness_proportionate_selection(
+            j = self.fitness_proportionate_selection(
                 scores, fitness_transformation=self.fitness_transformation
             )
         return j
@@ -362,7 +363,7 @@ def score_all(self) -> List:
                 noise=self.noise,
                 game=self.game,
                 deterministic_cache=self.deterministic_cache,
-                seed=self._random.random_seed_int()
+                seed=next(self._bulk_random)
             )
             match.play()
             match_scores = match.final_score_per_turn()

axelrod/random_.py

@@ -119,23 +119,26 @@ class BulkRandomGenerator(object):
     """Bulk generator of random integers for tournament seeding
     and reproducibility. Use like a generator."""
     def __init__(self, seed=None, batch_size=1000):
-        self.random_generator = RandomState()
-        self.random_generator.seed(seed)
+        self._random_generator = RandomState()
+        self._random_generator.seed(seed)
         self._ints = None
-        self.batch_size = batch_size
+        self._batch_size = batch_size
+        self._index = 0
         self._fill_ints()
 
     def _fill_ints(self):
-        ints = self.random_generator.randint(
+        ints = self._random_generator.randint(
             low=0,
             high=2**32 - 1,
-            size=self.batch_size)
-        self._ints = (x for x in ints)
+            size=self._batch_size)
+        self._ints = [x for x in ints]
+        self._index = 0
 
     def __next__(self):
         try:
-            x = next(self._ints)
+            x = self._ints[self._index]
+            self._index += 1
             return x
-        except StopIteration:
+        except IndexError:
             self._fill_ints()
-            return next(self._ints)
+            return self.__next__()

axelrod/result_set.py

@@ -5,11 +5,11 @@
 
 import numpy as np
 import tqdm
-from axelrod.action import Action
 
 import dask as da
 import dask.dataframe as dd
 
+from axelrod.action import Action
 from . import eigen
 
 C, D = Action.C, Action.D

axelrod/strategies/ann.py

@@ -1,6 +1,5 @@
 from typing import List, Tuple
 import numpy as np
-import numpy.random as random
 from axelrod.action import Action
 from axelrod.load_data_ import load_weights
 from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, crossover_lists
@@ -229,7 +228,9 @@ def __init__(
         weights: List[float] = None,
         mutation_probability: float = None,
         mutation_distance: int = 5,
+        seed: int = None
     ) -> None:
+        self.set_seed(seed=seed)
         num_features, num_hidden, weights, mutation_probability = self._normalize_parameters(
             num_features, num_hidden, weights, mutation_probability)
         ANN.__init__(self,
@@ -245,25 +246,23 @@ def __init__(
             weights=weights,
             mutation_probability=mutation_probability)
 
-    @classmethod
-    def _normalize_parameters(cls, num_features=None, num_hidden=None, weights=None, mutation_probability=None):
+    def _normalize_parameters(self, num_features=None, num_hidden=None, weights=None, mutation_probability=None):
         if not (num_features and num_hidden):
             raise InsufficientParametersError("Insufficient Parameters to instantiate EvolvableANN")
         size = num_weights(num_features, num_hidden)
         if not weights:
-            weights = [random.uniform(-1, 1) for _ in range(size)]
+            weights = [self._random.uniform(-1, 1) for _ in range(size)]
         if mutation_probability is None:
             mutation_probability = 10. / size
         return num_features, num_hidden, weights, mutation_probability
 
-    @staticmethod
-    def mutate_weights(weights, num_features, num_hidden, mutation_probability,
+    def mutate_weights(self, weights, num_features, num_hidden, mutation_probability,
                        mutation_distance):
         size = num_weights(num_features, num_hidden)
-        randoms = random.random(size)
+        randoms = self._random.random(size)
         for i, r in enumerate(randoms):
             if r < mutation_probability:
-                p = 1 + random.uniform(-1, 1) * mutation_distance
+                p = 1 + self._random.uniform(-1, 1) * mutation_distance
                 weights[i] *= p
         return weights
 
@@ -276,7 +275,7 @@ def mutate(self):
     def crossover(self, other):
         if other.__class__ != self.__class__:
             raise TypeError("Crossover must be between the same player classes.")
-        weights = crossover_lists(self.weights, other.weights)
+        weights = crossover_lists(self.weights, other.weights, self._random)
         return self.create_new(weights=weights)