Additional behavior tests for Evolvable players

Author: marcharper

axelrod/evolvable_player.py

@@ -1,11 +1,10 @@
 from pickle import dumps, loads
-import random
+from random import randrange
 from .player import Player
 
 
 class InsufficientParametersError(Exception):
     """Error indicating that insufficient parameters were specified to initialize an Evolvable Player."""
-
     def __init__(self, *args):
         super().__init__(*args)
 
@@ -17,6 +16,8 @@ class EvolvablePlayer(Player):
     """
 
     name = "EvolvablePlayer"
+    parent_class = Player
+    parent_kwargs = []
 
     def overwrite_init_kwargs(self, **kwargs):
         """Use to overwrite parameters for proper cloning and testing."""
@@ -69,20 +70,14 @@ def copy_lists(lists):
 
 
 def crossover_lists(list1, list2):
-    cross_point = random.randrange(len(list1))
+    cross_point = randrange(len(list1))
     new_list = list(list1[:cross_point]) + list(list2[cross_point:])
     return new_list
 
 
-def crossover_lists_of_lists(lists1, lists2):
-    cross_point = random.randrange(len(lists1))
-    new_lists = copy_lists(lists1[:cross_point]) + copy_lists(lists2[cross_point:])
-    return new_lists
-
-
 def crossover_dictionaries(table1, table2):
     keys = list(table1.keys())
-    cross_point = random.randrange(len(keys))
+    cross_point = randrange(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/moran.py

@@ -1,7 +1,8 @@
 """Implementation of the Moran process on Graphs."""
 
-import random
 from collections import Counter
+import random
+from random import randrange
 from typing import Callable, List, Optional, Set, Tuple
 
 import matplotlib.pyplot as plt
@@ -11,7 +12,6 @@
 from .deterministic_cache import DeterministicCache
 from .graph import Graph, complete_graph
 from .match import Match
-from .random_ import randrange
 
 
 def fitness_proportionate_selection(

axelrod/random_.py

@@ -1,11 +1,19 @@
 import random
 
-import numpy
+import numpy as np
+from numpy.random import choice
+
 from axelrod.action import Action
 
 C, D = Action.C, Action.D
 
 
+def seed(seed_):
+    """Sets a seed"""
+    random.seed(seed_)
+    np.random.seed(seed_)
+
+
 def random_choice(p: float = 0.5) -> Action:
     """
     Return C with probability `p`, else return D
@@ -55,18 +63,24 @@ def random_flip(action: Action, threshold: float) -> Action:
     return action
 
 
-def randrange(a: int, b: int) -> int:
-    """Python 2 / 3 compatible randrange. Returns a random integer uniformly
-    between a and b (inclusive)"""
-    c = b - a
-    r = c * random.random()
-    return a + int(r)
+# def randrange(a: int, b: int) -> int:
+#     """Python 2 / 3 compatible randrange. Returns a random integer uniformly
+#     between a and b (inclusive)"""
+#     c = b - a
+#     r = c * random.random()
+#     return a + int(r)
 
 
-def seed(seed_):
-    """Sets a seed"""
-    random.seed(seed_)
-    numpy.random.seed(seed_)
+def random_vector(size):
+    """Create a random vector of values in [0, 1] that sums to 1."""
+    vector = []
+    s = 1
+    for _ in range(size - 1):
+        r = s * random.random()
+        vector.append(r)
+        s -= r
+    vector.append(s)
+    return vector
 
 
 class Pdf(object):
@@ -81,7 +95,7 @@ def __init__(self, counter):
 
     def sample(self):
         """Sample from the pdf"""
-        index = numpy.random.choice(a=range(self.size), p=self.probability)
+        index = choice(a=range(self.size), p=self.probability)
         # Numpy cannot sample from a list of n dimensional objects for n > 1,
         # need to sample an index.
         return self.sample_space[index]

axelrod/strategies/ann.py

@@ -1,7 +1,6 @@
-import random
 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
@@ -260,7 +259,7 @@ def _normalize_parameters(cls, num_features=None, num_hidden=None, weights=None,
     def mutate_weights(weights, num_features, num_hidden, mutation_probability,
                        mutation_distance):
         size = num_weights(num_features, num_hidden)
-        randoms = np.random.random(size)
+        randoms = random.random(size)
         for i, r in enumerate(randoms):
             if r < mutation_probability:
                 p = 1 + random.uniform(-1, 1) * mutation_distance

axelrod/strategies/cycler.py

@@ -102,6 +102,8 @@ def set_cycle(self, cycle):
 class EvolvableCycler(Cycler, EvolvablePlayer):
     """Evolvable version of Cycler."""
 
+    name = "EvolvableCycler"
+
     def __init__(
         self,
         cycle: str = None,

axelrod/strategies/finite_state_machines.py

@@ -1,14 +1,11 @@
 import itertools
-import random
-from random import randrange, choice
-
-import numpy as np
-
+from random import randrange
+import numpy.random as random
+from numpy.random import choice
 from axelrod.action import Action, UnknownActionError
 from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, copy_lists
 from axelrod.player import Player
 
-
 C, D = Action.C, Action.D
 actions = (C, D)
 
@@ -203,7 +200,7 @@ def random_params(cls, num_states):
     @staticmethod
     def mutate_rows(rows, mutation_probability):
         rows = list(rows)
-        randoms = np.random.random(len(rows))
+        randoms = random.random(len(rows))
         # Flip each value with a probability proportional to the mutation rate
         for i, row in enumerate(rows):
             if randoms[i] < mutation_probability:
@@ -298,7 +295,7 @@ def repr_rows(rows):
         ss = []
         for row in rows:
             ss.append("_".join(list(map(str, row))))
-        return ":".join(ss)
+        return "|".join(ss)
 
     def serialize_parameters(self):
         return "{}:{}:{}:{}".format(
@@ -316,7 +313,7 @@ def deserialize_parameters(cls, serialized):
         initial_state = int(lines[1])
         initial_action = Action.from_char(lines[2])
 
-        for line in lines[3:]:
+        for line in lines[3].split('|'):
             row = []
             for element in line.split('_'):
                 try:

axelrod/strategies/gambler.py

@@ -5,9 +5,7 @@
  https://gist.github.com/GDKO/60c3d0fd423598f3c4e4
 """
 import random
-from random import choice
 from typing import Any
-import numpy as np
 
 from axelrod.action import Action, str_to_actions, actions_to_str
 from axelrod.load_data_ import load_pso_tables

axelrod/strategies/hmm.py

@@ -1,13 +1,11 @@
-import random
 from random import randrange
-import numpy as np
+import numpy.random as random
 from numpy.random import choice
 
 from axelrod.action import Action
-from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, crossover_lists, crossover_lists_of_lists
+from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, copy_lists, crossover_lists
 from axelrod.player import Player
-
-from axelrod.random_ import random_choice
+from axelrod.random_ import random_choice, random_vector
 
 C, D = Action.C, Action.D
 
@@ -24,23 +22,6 @@ def is_stochastic_matrix(m, ep=1e-8) -> bool:
     return True
 
 
-def copy_lists(rows):
-    new_rows = list(map(list, rows))
-    return new_rows
-
-
-def random_vector(size):
-    """Create a random vector of values in [0, 1] that sums to 1."""
-    vector = []
-    s = 1
-    for _ in range(size - 1):
-        r = s * random.random()
-        vector.append(r)
-        s -= r
-    vector.append(s)
-    return vector
-
-
 def normalize_vector(vec):
     s = sum(vec)
     if s == 0.0:
@@ -51,13 +32,13 @@ def normalize_vector(vec):
 
 
 def mutate_row(row, mutation_probability):
-    """
+    """, crossover_lists_of_lists
     Given a row of probabilities, randomly change each entry with probability
     `mutation_probability` (a value between 0 and 1).  If changing, then change
     by a value randomly (uniformly) chosen from [-0.25, 0.25] bounded by 0 and
     100%.
     """
-    randoms = np.random.random(len(row))
+    randoms = random.random(len(row))
     for i in range(len(row)):
         if randoms[i] < mutation_probability:
             ep = random.uniform(-1, 1) / 4
@@ -211,6 +192,8 @@ def strategy(self, opponent: Player) -> Action:
 
 class EvolvableHMMPlayer(HMMPlayer, EvolvablePlayer):
     """Evolvable version of HMMPlayer."""
+    name = "EvolvableHMMPlayer"
+
     def __init__(
         self,
         transitions_C=None,
@@ -309,8 +292,8 @@ def mutate(self):
     def crossover(self, other):
         if not isinstance(other, self.__class__):
             raise TypeError("Crossover must be between the same player classes.")
-        transitions_C = crossover_lists_of_lists(self.hmm.transitions_C, other.hmm.transitions_C)
-        transitions_D = crossover_lists_of_lists(self.hmm.transitions_D, other.hmm.transitions_D)
+        transitions_C = crossover_lists(self.hmm.transitions_C, other.hmm.transitions_C)
+        transitions_D = crossover_lists(self.hmm.transitions_D, other.hmm.transitions_D)
         emission_probabilities = crossover_lists(
             self.hmm.emission_probabilities, other.hmm.emission_probabilities)
         return self.create_new(

axelrod/strategies/lookerup.py

@@ -1,10 +1,9 @@
 from collections import namedtuple
 from itertools import product
-import random
-from random import choice
 from typing import Any, TypeVar
 
-import numpy as np
+import numpy.random as random
+from numpy.random import choice
 
 from axelrod.action import Action, actions_to_str, str_to_actions
 from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, crossover_dictionaries
@@ -464,7 +463,7 @@ def _normalize_parameters(cls, lookup_dict=None, initial_actions=None, pattern=N
 
     @classmethod
     def random_value(cls):
-        return random.choice(actions)
+        return choice(actions)
 
     @classmethod
     def random_params(cls, plays, op_plays, op_start_plays):
@@ -480,7 +479,7 @@ def mutate_value(cls, value):
 
     @classmethod
     def mutate_table(cls, table, mutation_probability):
-        randoms = np.random.random(len(table.keys()))
+        randoms = random.random(len(table.keys()))
         # Flip each value with a probability proportional to the mutation rate
         for i, (history, move) in enumerate(table.items()):
             if randoms[i] < mutation_probability:

axelrod/tests/strategies/test_ann.py

@@ -43,12 +43,16 @@ def test_normalized_parameters(self):
 class TestEvolvableANN2(TestEvolvablePlayer):
     name = "EvolvableANN"
     player_class = axelrod.EvolvableANN
+    parent_class = axelrod.ANN
+    parent_kwargs = ["num_features", "num_hidden", "weights"]
     init_parameters = {"num_features": 17, "num_hidden": 8}
 
 
 class TestEvolvableANN3(TestEvolvablePlayer):
     name = "EvolvableANN"
     player_class = axelrod.EvolvableANN
+    parent_class = axelrod.ANN
+    parent_kwargs = ["num_features", "num_hidden", "weights"]
     init_parameters = {
         "num_features": nn_weights["Evolved ANN 5"][0],
         "num_hidden": nn_weights["Evolved ANN 5"][1],