Fix many tests and errors for seed setting and propagation

Author: marcharper

axelrod/__init__.py

@@ -2,9 +2,17 @@
 
 # The order of imports matters!
 from axelrod.version import __version__
+from axelrod.action import Action
+from axelrod.random_ import Pdf, RandomGenerator, BulkRandomGenerator
+
+# Initialize module level Random
+# This is 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
+_module_random = RandomGenerator()
+
 from axelrod.load_data_ import load_pso_tables, load_weights
 from axelrod import graph
-from axelrod.action import Action
 from axelrod.random_ import Pdf, RandomGenerator, BulkRandomGenerator
 from axelrod.plot import Plot
 from axelrod.game import DefaultGame, Game

axelrod/match.py

@@ -70,7 +70,6 @@ def __init__(
         self.noise = noise
 
         self.seed = seed
-        self._random = RandomGenerator(seed=self.seed)
 
         if game is None:
             self.game = Game()
@@ -143,8 +142,8 @@ def simultaneous_play(self, player, coplayer, noise=0):
             # Note this uses the Match classes random generator, not either
             # player's random generator. A player shouldn't be able to
             # predict the outcome of this noise flip.
-            s1 = self.random_flip(s1, noise)
-            s2 = self.random_flip(s2, noise)
+            s1 = self._random.random_flip(s1, noise)
+            s2 = self._random.random_flip(s2, noise)
         player.update_history(s1, s2)
         coplayer.update_history(s2, s1)
         return s1, s2
@@ -167,18 +166,23 @@ def play(self):
 
         i.e. One entry per turn containing a pair of actions.
         """
+        # if self._stochastic:
         self._random = RandomGenerator(seed=self.seed)
-        r = self._random.random()
-        turns = min(sample_length(self.prob_end, r), self.turns)
+        if self.prob_end:
+            r = self._random.random()
+            turns = min(sample_length(self.prob_end, r), self.turns)
+        else:
+            turns = self.turns
         cache_key = (self.players[0], self.players[1])
 
         if self._stochastic or not self._cached_enough_turns(cache_key, turns):
             for p in self.players:
                 if self.reset:
                     p.reset()
                 p.set_match_attributes(**self.match_attributes)
-                # Generate a random seed for each player
-                p.set_seed(self._random.randint(0, 100000000))
+                # if p.classifier["stochastic"]:
+                # Generate a random seed for the player
+                p.set_seed(self._random.random_seed_int())
             result = []
             for _ in range(turns):
                 plays = self.simultaneous_play(

axelrod/moran.py

@@ -29,7 +29,7 @@ def __init__(
         fitness_transformation: Callable = None,
         mutation_method="transition",
         stop_on_fixation=True,
-        seed = None
+        seed=None
     ) -> None:
         """
         An agent based Moran process class. In each round, each player plays a
@@ -362,6 +362,7 @@ def score_all(self) -> List:
                 noise=self.noise,
                 game=self.game,
                 deterministic_cache=self.deterministic_cache,
+                seed=self._random.random_seed_int()
             )
             match.play()
             match_scores = match.final_score_per_turn()

axelrod/player.py

@@ -6,6 +6,7 @@
 
 import numpy as np
 
+from axelrod import _module_random
 from axelrod.action import Action
 from axelrod.game import DefaultGame
 from axelrod.history import History
@@ -70,14 +71,26 @@ def __new__(cls, *args, **kwargs):
         """Caches arguments for Player cloning."""
         obj = super().__new__(cls)
         obj.init_kwargs = cls.init_params(*args, **kwargs)
+        # # Set up random seed from the module level random seed
+        # # in case the user doesn't specific one later.
+        # need_seed = False
+        # try:
+        #     seed = kwargs["seed"]
+        #     if seed is None:
+        #         need_seed = True
+        # except KeyError:
+        #     need_seed = True
+        # if need_seed:
+        #     seed = _module_random.randint(0, 2**32-1)
+        # obj._seed = seed
         return obj
 
     @classmethod
     def init_params(cls, *args, **kwargs):
         """
         Return a dictionary containing the init parameters of a strategy
         (without 'self').
-        Use *args and *kwargs as value if specified
+        Use *args and **kwargs as value if specified
         and complete the rest with the default values.
         """
         sig = inspect.signature(cls.__init__)
@@ -99,7 +112,7 @@ def __init__(self):
             if dimension not in self.classifier:
                 self.classifier[dimension] = self.default_classifier[dimension]
         self.set_match_attributes()
-        self.set_seed()
+        # self.set_seed(seed=self._seed)
 
     def __eq__(self, other):
         """
@@ -113,8 +126,8 @@ def __eq__(self, other):
             value = getattr(self, attribute, None)
             other_value = getattr(other, attribute, None)
 
-            if attribute == "_random":
-                # Don't compare the random seeds.
+            if attribute in ["_random", "_seed"]:
+                # Don't compare the random generators.
                 continue
 
             if isinstance(value, np.ndarray):
@@ -164,9 +177,13 @@ def set_match_attributes(self, length=-1, game=None, noise=0):
         self.receive_match_attributes()
 
     def set_seed(self, seed=None):
-        """Set a random seed for the player's random number
-        generator."""
-        self._random = RandomGenerator(seed=seed)
+        """Set a random seed for the player's random number generator."""
+        if seed is None:
+            # Warning: using global seed
+            self._seed = _module_random.random_seed_int()
+        else:
+            self._seed = seed
+        self._random = RandomGenerator(seed=self._seed)
 
     def __repr__(self):
         """The string method for the strategy.
@@ -207,6 +224,7 @@ def clone(self):
         cls = self.__class__
         new_player = cls(**self.init_kwargs)
         new_player.match_attributes = copy.copy(self.match_attributes)
+        # new_player.set_seed(self._seed)
         return new_player
 
     def reset(self):
@@ -218,6 +236,7 @@ def reset(self):
         """
         # This also resets the history.
         self.__init__(**self.init_kwargs)
+        # self.set_seed(self._seed)
 
     def update_history(self, play, coplay):
         self.history.append(play, coplay)

axelrod/random_.py

@@ -27,6 +27,9 @@ def random(self, *args, **kwargs):
     def randint(self, *args, **kwargs):
         return self._random.randint(*args, **kwargs)
 
+    def random_seed_int(self):
+        return self.randint(0, 2**32-1)
+
     def choice(self, *args, **kwargs):
         return self._random.choice(*args, **kwargs)
 

axelrod/strategies/hmm.py

@@ -58,8 +58,7 @@ class SimpleHMM(object):
     """
 
     def __init__(
-        self, transitions_C, transitions_D, emission_probabilities, initial_state,
-        seed=None
+        self, transitions_C, transitions_D, emission_probabilities, initial_state
     ) -> None:
         """
         Params
@@ -73,7 +72,6 @@ def __init__(
         self.transitions_D = transitions_D
         self.emission_probabilities = emission_probabilities
         self.state = initial_state
-        self._random = RandomGenerator(seed=seed)
 
     def is_well_formed(self) -> bool:
         """
@@ -161,8 +159,7 @@ def __init__(
         self.initial_state = initial_state
         self.initial_action = initial_action
         self.hmm = SimpleHMM(
-            copy_lists(transitions_C), copy_lists(transitions_D), list(emission_probabilities), initial_state,
-            seed=self._random.randint(0, 10000000)
+            copy_lists(transitions_C), copy_lists(transitions_D), list(emission_probabilities), initial_state
         )
         assert self.hmm.is_well_formed()
         self.state = self.hmm.state
@@ -190,6 +187,11 @@ def strategy(self, opponent: Player) -> Action:
             self.state = self.hmm.state
             return action
 
+    def set_seed(self, seed=None):
+        super().set_seed(seed=seed)
+        # Share RNG with HMM
+        self.hmm._random = self._random
+
 
 class EvolvableHMMPlayer(HMMPlayer, EvolvablePlayer):
     """Evolvable version of HMMPlayer."""

axelrod/strategies/memoryone.py

@@ -91,7 +91,10 @@ def strategy(self, opponent: Player) -> Action:
         # Determine which probability to use
         p = self._four_vector[(self.history[-1], opponent.history[-1])]
         # Draw a random number in [0, 1] to decide
-        return self._random.random_choice(p)
+        try:
+            return self._random.random_choice(p)
+        except AttributeError:
+            return D if p == 0 else C
 
 
 class WinStayLoseShift(MemoryOnePlayer):

axelrod/strategies/memorytwo.py

@@ -102,7 +102,10 @@ def strategy(self, opponent: Player) -> Action:
             (tuple(self.history[-2:]), tuple(opponent.history[-2:]))
         ]
         # Draw a random number in [0, 1] to decide
-        return self._random.random_choice(p)
+        try:
+            return self._random.random_choice(p)
+        except AttributeError:
+            return D if p == 0 else C
 
 
 class AON2(MemoryTwoPlayer):

axelrod/strategies/meta.py

@@ -57,7 +57,6 @@ def __init__(self, team=None):
         self.team = [t() for t in self.team]
 
         super().__init__()
-        self.set_seed()
 
         # This player inherits the classifiers of its team.
         # Note that memory_depth is not simply the max memory_depth of the team.
@@ -75,9 +74,10 @@ def __init__(self, team=None):
         self._last_results = None
 
     def set_seed(self, seed=None):
-        super().set_seed(seed)
+        super().set_seed(seed=seed)
+        # Seed the team as well
         for t in self.team:
-            t.set_seed(self._random.randint(0, 100000000))
+            t.set_seed(self._random.random_seed_int())
 
     def receive_match_attributes(self):
         for t in self.team:

axelrod/strategies/oncebitten.py

@@ -1,5 +1,3 @@
-import random
-
 from axelrod.action import Action
 from axelrod.player import Player
 
@@ -118,7 +116,7 @@ def __init__(self, forget_probability: float = 0.05) -> None:
         self.forget_probability = forget_probability
 
     def strategy(self, opponent: Player) -> Action:
-        r = random.random()
+        r = self._random.random()
         if not opponent.history:
             return self._initial
         if opponent.history[-1] == D: