First pass on reproducible matches and parallel tournaments with random seeding

Author: marcharper

axelrod/__init__.py

@@ -5,7 +5,7 @@
 from axelrod.load_data_ import load_pso_tables, load_weights
 from axelrod import graph
 from axelrod.action import Action
-from axelrod.random_ import random_choice, random_flip, seed, Pdf
+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/match.py

@@ -1,11 +1,11 @@
-import random
 from math import ceil, log
 
 import axelrod.interaction_utils as iu
 from axelrod import DEFAULT_TURNS
 from axelrod.action import Action
 from axelrod import Classifiers
 from axelrod.game import Game
+from axelrod.random_ import RandomGenerator
 from .deterministic_cache import DeterministicCache
 
 C, D = Action.C, Action.D
@@ -30,6 +30,7 @@ def __init__(
         noise=0,
         match_attributes=None,
         reset=True,
+        seed=None
     ):
         """
         Parameters
@@ -52,6 +53,8 @@ def __init__(
             but these can be overridden if desired.
         reset : bool
             Whether to reset players or not
+        seed : int
+            Random seed for reproducibility
         """
 
         defaults = {
@@ -65,6 +68,9 @@ def __init__(
         self.result = []
         self.noise = noise
 
+        self.seed = seed
+        self._random = RandomGenerator(seed=self.seed)
+
         if game is None:
             self.game = Game()
         else:
@@ -129,6 +135,19 @@ def _cached_enough_turns(self, cache_key, turns):
             return False
         return len(self._cache[cache_key]) >= turns
 
+    def simultaneous_play(self, player, coplayer, noise=0):
+        """This pits two players against each other."""
+        s1, s2 = player.strategy(coplayer), coplayer.strategy(player)
+        if noise:
+            # 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)
+        player.update_history(s1, s2)
+        coplayer.update_history(s2, s1)
+        return s1, s2
+
     def play(self):
         """
         The resulting list of actions from a match between two players.
@@ -147,17 +166,22 @@ def play(self):
 
         i.e. One entry per turn containing a pair of actions.
         """
-        turns = min(sample_length(self.prob_end), self.turns)
+        self._random = RandomGenerator(seed=self.seed)
+        r = self._random.random()
+        turns = min(sample_length(self.prob_end, r), 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))
             result = []
             for _ in range(turns):
-                plays = self.players[0].play(self.players[1], self.noise)
+                plays = self.simultaneous_play(
+                    self.players[0], self.players[1], self.noise)
                 result.append(plays)
 
             if self._cache_update_required:
@@ -216,7 +240,7 @@ def __len__(self):
         return self.turns
 
 
-def sample_length(prob_end):
+def sample_length(prob_end, random_value):
     """
     Sample length of a game.
 
@@ -249,5 +273,4 @@ def sample_length(prob_end):
         return float("inf")
     if prob_end == 1:
         return 1
-    x = random.random()
-    return int(ceil(log(1 - x) / log(1 - prob_end)))
+    return int(ceil(log(1 - random_value) / log(1 - prob_end)))

axelrod/match_generator.py

@@ -1,3 +1,6 @@
+from axelrod.random_ import BulkRandomGenerator
+
+
 class MatchGenerator(object):
     def __init__(
         self,
@@ -9,6 +12,7 @@ def __init__(
         prob_end=None,
         edges=None,
         match_attributes=None,
+        seed=None
     ):
         """
         A class to generate matches. This is used by the Tournament class which
@@ -43,6 +47,7 @@ def __init__(
         self.opponents = players
         self.prob_end = prob_end
         self.match_attributes = match_attributes
+        self.random_generator = BulkRandomGenerator(seed)
 
         self.edges = edges
         if edges is not None:
@@ -73,7 +78,8 @@ def build_match_chunks(self):
 
         for index_pair in edges:
             match_params = self.build_single_match_params()
-            yield (index_pair, match_params, self.repetitions)
+            r = next(self.random_generator)
+            yield (index_pair, match_params, self.repetitions, r)
 
     def build_single_match_params(self):
         """

axelrod/moran.py

@@ -1,6 +1,5 @@
 """Implementation of the Moran process on Graphs."""
 
-import random
 from collections import Counter
 from typing import Callable, List, Optional, Set, Tuple
 
@@ -11,35 +10,7 @@
 from .deterministic_cache import DeterministicCache
 from .graph import Graph, complete_graph
 from .match import Match
-from .random_ import randrange
-
-
-def fitness_proportionate_selection(
-    scores: List, fitness_transformation: Callable = None
-) -> int:
-    """Randomly selects an individual proportionally to score.
-
-    Parameters
-    ----------
-    scores: Any sequence of real numbers
-    fitness_transformation: A function mapping a score to a (non-negative) float
-
-    Returns
-    -------
-    An index of the above list selected at random proportionally to the list
-    element divided by the total.
-    """
-    if fitness_transformation is None:
-        csums = np.cumsum(scores)
-    else:
-        csums = np.cumsum([fitness_transformation(s) for s in scores])
-    total = csums[-1]
-    r = random.random() * total
-
-    for i, x in enumerate(csums):
-        if x >= r:
-            break
-    return i
+from .random_ import RandomGenerator
 
 
 class MoranProcess(object):
@@ -57,7 +28,8 @@ def __init__(
         reproduction_graph: Graph = None,
         fitness_transformation: Callable = None,
         mutation_method="transition",
-        stop_on_fixation=True
+        stop_on_fixation=True,
+        seed = None
     ) -> None:
         """
         An agent based Moran process class. In each round, each player plays a
@@ -128,6 +100,7 @@ def __init__(
         self.winning_strategy_name = None  # type: Optional[str]
         self.mutation_rate = mutation_rate
         self.stop_on_fixation = stop_on_fixation
+        self._random = RandomGenerator(seed=seed)
         m = mutation_method.lower()
         if m in ["atomic", "transition"]:
             self.mutation_method = m
@@ -182,6 +155,32 @@ def set_players(self) -> None:
             self.players.append(player)
         self.populations = [self.population_distribution()]
 
+    def fitness_proportionate_selection(self,
+                                        scores: List, fitness_transformation: Callable = None) -> int:
+        """Randomly selects an individual proportionally to score.
+
+        Parameters
+        ----------
+        scores: Any sequence of real numbers
+        fitness_transformation: A function mapping a score to a (non-negative) float
+
+        Returns
+        -------
+        An index of the above list selected at random proportionally to the list
+        element divided by the total.
+        """
+        if fitness_transformation is None:
+            csums = np.cumsum(scores)
+        else:
+            csums = np.cumsum([fitness_transformation(s) for s in scores])
+        total = csums[-1]
+        r = self._random.random() * total
+
+        for i, x in enumerate(csums):
+            if x >= r:
+                break
+        return i
+
     def mutate(self, index: int) -> Player:
         """Mutate the player at index.
 
@@ -199,10 +198,10 @@ def mutate(self, index: int) -> Player:
         # Assuming mutation_method == "transition"
         if self.mutation_rate > 0:
             # Choose another strategy at random from the initial population
-            r = random.random()
+            r = self._random.random()
             if r < self.mutation_rate:
                 s = str(self.players[index])
-                j = randrange(0, len(self.mutation_targets[s]))
+                j = self._random.randrange(0, len(self.mutation_targets[s]))
                 p = self.mutation_targets[s][j]
                 return p.clone()
         # Just clone the player
@@ -223,13 +222,13 @@ def death(self, index: int = None) -> int:
         """
         if index is None:
             # Select a player to be replaced globally
-            i = randrange(0, len(self.players))
+            i = self._random.randrange(0, len(self.players))
             # Record internally for use in _matchup_indices
             self.dead = i
         else:
             # Select locally
             # index is not None in this case
-            vertex = random.choice(
+            vertex = self._random.choice(
                 sorted(self.reproduction_graph.out_vertices(self.locations[index]))
             )
             i = self.index[vertex]

axelrod/player.py

@@ -9,22 +9,11 @@
 from axelrod.action import Action
 from axelrod.game import DefaultGame
 from axelrod.history import History
-from axelrod.random_ import random_flip
+from axelrod.random_ import RandomGenerator
 
 C, D = Action.C, Action.D
 
 
-def simultaneous_play(player, coplayer, noise=0):
-    """This pits two players against each other."""
-    s1, s2 = player.strategy(coplayer), coplayer.strategy(player)
-    if noise:
-        s1 = random_flip(s1, noise)
-        s2 = random_flip(s2, noise)
-    player.update_history(s1, s2)
-    coplayer.update_history(s2, s1)
-    return s1, s2
-
-
 class Player(object):
     """A class for a player in the tournament.
 
@@ -64,6 +53,7 @@ def __init__(self):
         self._history = History()
         self.classifier = copy.deepcopy(self.classifier)
         self.set_match_attributes()
+        self.set_seed()
 
     def __eq__(self, other):
         """
@@ -77,6 +67,10 @@ def __eq__(self, other):
             value = getattr(self, attribute, None)
             other_value = getattr(other, attribute, None)
 
+            if attribute == "_random":
+                # Don't compare the random seeds.
+                continue
+
             if isinstance(value, np.ndarray):
                 if not (np.array_equal(value, other_value)):
                     return False
@@ -123,6 +117,11 @@ def set_match_attributes(self, length=-1, game=None, noise=0):
         self.match_attributes = {"length": length, "game": game, "noise": noise}
         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)
+
     def __repr__(self):
         """The string method for the strategy.
         Appends the `__init__` parameters to the strategy's name."""
@@ -147,9 +146,9 @@ def strategy(self, opponent):
         """This is a placeholder strategy."""
         raise NotImplementedError()
 
-    def play(self, opponent, noise=0):
-        """This pits two players against each other."""
-        return simultaneous_play(self, opponent, noise)
+    # def play(self, opponent, noise=0):
+    #     """This pits two players against each other."""
+    #     return simultaneous_play(self, opponent, noise)
 
     def clone(self):
         """Clones the player without history, reapplying configuration