Fix many tests and errors for seed setting and propagation

marcharper · marcharper · commit 59af2aa31b1c · 2020-02-27T23:14:57.000-08:00
diff --git a/axelrod/__init__.py b/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
diff --git a/axelrod/match.py b/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(
diff --git a/axelrod/moran.py b/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()
diff --git a/axelrod/player.py b/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)
diff --git a/axelrod/random_.py b/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)
 
diff --git a/axelrod/strategies/hmm.py b/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."""
diff --git a/axelrod/strategies/memoryone.py b/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):
diff --git a/axelrod/strategies/memorytwo.py b/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):
diff --git a/axelrod/strategies/meta.py b/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:
diff --git a/axelrod/strategies/oncebitten.py b/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:
diff --git a/axelrod/strategies/punisher.py b/axelrod/strategies/punisher.py
@@ -1,5 +1,3 @@
-from typing import List
-
 from axelrod.action import Action
 from axelrod.player import Player
 
diff --git a/axelrod/strategies/revised_downing.py b/axelrod/strategies/revised_downing.py
@@ -7,6 +7,7 @@
 
 C, D = Action.C, Action.D
 
+
 class RevisedDowning(Player):
     """
     Strategy submitted to Axelrod's second tournament by Leslie Downing.
diff --git a/axelrod/strategies/titfortat.py b/axelrod/strategies/titfortat.py
@@ -839,7 +839,10 @@ def strategy(self, opponent: Player) -> Action:
 
         if self.act_random:
             self.act_random = False
-            return self._random.random_choice(self.p)
+            try:
+                return self._random.random_choice(self.p)
+            except AttributeError:
+                return D if self.p == 0 else C
 
         self.act_random = True
         return opponent.history[-1]
diff --git a/axelrod/tests/strategies/test_evolvable_player.py b/axelrod/tests/strategies/test_evolvable_player.py
@@ -3,13 +3,15 @@
 import unittest
 
 import axelrod as axl
-from axelrod import EvolvablePlayer, seed
+from axelrod import EvolvablePlayer
 from axelrod.action import Action
 from axelrod.evolvable_player import copy_lists, crossover_lists, crossover_dictionaries
 from .test_player import TestPlayer
 
 C, D = Action.C, Action.D
 
+def seed(x):
+    return
 
 def PartialClass(cls, **kwargs):
 
@@ -154,14 +156,12 @@ def test_serialization_csv(self):
     def behavior_test(self, player1, player2):
         """Test that the evolvable player plays the same as its (nonevolvable) parent class."""
         for opponent_class in [axl.Random, axl.TitForTat, axl.Alternator]:
-            axl.seed(0)
             opponent = opponent_class()
-            match = axl.Match((player1.clone(), opponent))
+            match = axl.Match((player1.clone(), opponent), seed=7)
             results1 = match.play()
 
-            axl.seed(0)
             opponent = opponent_class()
-            match = axl.Match((player2.clone(), opponent))
+            match = axl.Match((player2.clone(), opponent), seed=7)
             results2 = match.play()
 
             self.assertEqual(results1, results2)
diff --git a/axelrod/tests/strategies/test_player.py b/axelrod/tests/strategies/test_player.py
@@ -405,8 +405,7 @@ def equality_of_players_test(self, p1, p2, seed, opponent):
         a2 = opponent()
         self.assertEqual(p1, p2)
         for player, op in [(p1, a1), (p2, a2)]:
-            m = axelrod.Match(players=(player, op), reset=True, seed=seed,
-                              turns=10)
+            m = axelrod.Match(players=(player, op), turns=10, seed=seed)
             m.play()
         self.assertEqual(p1, p2)
         p1 = pickle.loads(pickle.dumps(p1))
@@ -483,7 +482,7 @@ def test_clone(self, seed):
         self.assertEqual(player2.classifier, player1.classifier)
         self.assertEqual(player2.match_attributes, player1.match_attributes)
 
-        turns = 20
+        turns = 5
         for op in [
             axelrod.Cooperator(),
             axelrod.Defector(),
diff --git a/axelrod/tests/strategies/test_titfortat.py b/axelrod/tests/strategies/test_titfortat.py
@@ -9,7 +9,7 @@
 from hypothesis import given
 from hypothesis.strategies import integers
 
-from .test_player import TestMatch, TestPlayer
+from .test_player import TestPlayer
 
 C, D = axelrod.Action.C, axelrod.Action.D
 
diff --git a/axelrod/tests/unit/test_moran.py b/axelrod/tests/unit/test_moran.py
diff --git a/axelrod/tests/unit/test_pickling.py b/axelrod/tests/unit/test_pickling.py
diff --git a/axelrod/tournament.py b/axelrod/tournament.py
