Merge pull request #449 from Axelrod-Python/447

447 - Adding a Mixed decorator **and** metaplayer

Author: meatballs

axelrod/strategies/__init__.py

@@ -8,13 +8,14 @@
 from .meta import (
     MetaPlayer, MetaMajority, MetaMinority, MetaWinner, MetaHunter,
     MetaMajorityMemoryOne, MetaWinnerMemoryOne, MetaMajorityFiniteMemory,
-    MetaWinnerFiniteMemory, MetaMajorityLongMemory, MetaWinnerLongMemory
+    MetaWinnerFiniteMemory, MetaMajorityLongMemory, MetaWinnerLongMemory,
+    MetaMixer
     )
 
 strategies.extend((MetaHunter, MetaMajority, MetaMinority, MetaWinner,
                    MetaMajorityMemoryOne, MetaWinnerMemoryOne,
                    MetaMajorityFiniteMemory, MetaWinnerFiniteMemory,
-                   MetaMajorityLongMemory, MetaWinnerLongMemory))
+                   MetaMajorityLongMemory, MetaWinnerLongMemory, MetaMixer))
 
 # Distinguished strategy collections in addition to
 # `strategies` from _strategies.py

axelrod/strategies/meta.py

@@ -2,6 +2,7 @@
 from ._strategies import strategies
 from .hunter import DefectorHunter, AlternatorHunter, RandomHunter, MathConstantHunter, CycleHunter, EventualCycleHunter
 from .cooperator import Cooperator
+from numpy.random import choice
 
 # Needs to be computed manually to prevent circular dependency
 ordinary_strategies = [s for s in strategies if obey_axelrod(s)]
@@ -266,3 +267,42 @@ def __init__(self):
                 == float('inf')]
         super(MetaWinnerLongMemory, self).__init__(team=team)
         self.init_args = ()
+
+
+class MetaMixer(MetaPlayer):
+    """A player who randomly switches between a team of players.
+    If no distribution is passed then the player will uniformly choose between
+    sub players.
+
+    In essence this is creating a Mixed strategy.
+
+    Parameters
+    ----------
+    team : list of strategy classes, optional
+        Team of strategies that are to be randomly played
+        If none is passed will select the ordinary strategies.
+    distribution : list representing a probability distribution, optional
+        This gives the distribution from which to select the players.
+        If none is passed will select uniformly.
+    """
+
+    name = "Meta Mixer"
+
+    def __init__(self, team=None, distribution=None):
+
+        # The default is to use all strategies available, but we need to import the list
+        # at runtime, since _strategies import also _this_ module before defining the list.
+        if team:
+            self.team = team
+        else:
+            # Needs to be computed manually to prevent circular dependency
+            self.team = ordinary_strategies
+
+        self.distribution = distribution
+
+        super(MetaMixer, self).__init__()
+        self.init_args = (team, distribution)
+
+    def meta_strategy(self, results, opponent):
+        """Using the numpy.random choice function to sample with weights"""
+        return choice(results, p=self.distribution)

axelrod/strategy_transformers.py

@@ -8,7 +8,8 @@
 
 import inspect
 import random
-from types import FunctionType
+import collections
+from numpy.random import choice
 
 from .actions import Actions, flip_action
 from .random_ import random_choice
@@ -239,6 +240,46 @@ def apology_wrapper(player, opponent, action, myseq, opseq):
 ApologyTransformer = StrategyTransformerFactory(apology_wrapper,
                                                 name_prefix="Apologizing")
 
+
+def mixed_wrapper(player, opponent, action, probability, m_player):
+    """Randomly picks a strategy to play, either from a distribution on a list
+    of players or a single player.
+
+    In essence creating a mixed strategy.
+
+    Parameters
+    ----------
+
+    probability: a float (or integer: 0 or 1) OR an iterable representing a
+        an incomplete probability distribution (entries to do not have to sum to
+        1). Eg: 0, 1, [.5,.5], (.5,.3)
+    m_players: a single player class or iterable representing set of player
+        classes to mix from.
+        Eg: axelrod.TitForTat, [axelod.Cooperator, axelrod.Defector]
+    """
+
+    # If a single probability, player is passed
+    if isinstance(probability, float) or isinstance(probability, int):
+        m_player = [m_player]
+        probability = [probability]
+
+    # If a probability distribution, players is passed
+    if isinstance(probability, collections.Iterable) and \
+            isinstance(m_player, collections.Iterable):
+        mutate_prob = sum(probability)  # Prob of mutation
+        if mutate_prob > 0:
+            # Distribution of choice of mutation:
+            normalised_prob = [prob / float(mutate_prob)
+                               for prob in probability]
+            if random.random() < mutate_prob:
+                p = choice(list(m_player), p=normalised_prob)()
+                p.history = player.history
+                return p.strategy(opponent)
+
+    return action
+
+MixedTransformer = StrategyTransformerFactory(mixed_wrapper, name_prefix="Mutated")
+
 # Strategy wrappers as classes
 
 class RetaliationWrapper(object):
@@ -260,6 +301,7 @@ def __call__(self, player, opponent, action, retaliations):
 RetaliationTransformer = StrategyTransformerFactory(
     RetaliationWrapper(), name_prefix="Retaliating")
 
+
 class RetaliationUntilApologyWrapper(object):
     """Enforces the TFT rule that the opponent pay back a defection with a
     cooperation for the player to stop defecting."""

axelrod/tests/unit/test_meta.py

@@ -284,3 +284,51 @@ class TestMetaWinnerLongMemory(TestMetaPlayer):
 
     def test_strategy(self):
         self.first_play_test(C)
+
+
+class TestMetaMixer(TestMetaPlayer):
+
+    name = "Meta Mixer"
+    player = axelrod.MetaMixer
+    expected_classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': True,
+        'manipulates_source': False,
+        'inspects_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+
+        team = [axelrod.TitForTat, axelrod.Cooperator, axelrod.Grudger]
+        distribution = [.2, .5, .3]
+
+        P1 = axelrod.MetaMixer(team, distribution)
+        P2 = axelrod.Cooperator()
+
+        for k in range(100):
+            self.assertEqual(P1.strategy(P2), C)
+
+        team.append(axelrod.Defector)
+        distribution = [.2, .5, .3, 0]  # If add a defector but does not occur
+
+        P1 = axelrod.MetaMixer(team, distribution)
+
+        for k in range(100):
+            self.assertEqual(P1.strategy(P2), C)
+
+        distribution = [0, 0, 0, 1]  # If defector is only one that is played
+
+        P1 = axelrod.MetaMixer(team, distribution)
+
+        for k in range(100):
+            self.assertEqual(P1.strategy(P2), D)
+
+    def test_raise_error_in_distribution(self):
+        team = [axelrod.TitForTat, axelrod.Cooperator, axelrod.Grudger]
+        distribution = [.2, .5, .5]  # Not a valid probability distribution
+
+        P1 = axelrod.MetaMixer(team, distribution)
+        P2 = axelrod.Cooperator()
+
+        self.assertRaises(ValueError, P1.strategy, P2)

axelrod/tests/unit/test_strategy_transformers.py

@@ -13,7 +13,7 @@
 class TestTransformers(unittest.TestCase):
 
     def test_all_strategies(self):
-        # Attempt to transform each strategy to ensure that implemenation
+        # Attempt to transform each strategy to ensure that implementation
         # choices (like use of super) do not cause issues
         for s in axelrod.ordinary_strategies:
             opponent = axelrod.Cooperator()
@@ -212,6 +212,53 @@ def test_apology(self):
             p1.play(p2)
         self.assertEqual(p1.history, [D, D, C, D, D, C])
 
+    def test_mixed(self):
+        """Tests the MixedTransformer."""
+        probability = 1
+        MD = MixedTransformer(probability, axelrod.Cooperator)(axelrod.Defector)
+
+        p1 = MD()
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [C, C, C, C, C])
+
+        probability = 0
+        MD = MixedTransformer(probability, axelrod.Cooperator)(axelrod.Defector)
+
+        p1 = MD()
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [D, D, D, D, D])
+
+        # Decorating with list and distribution
+
+        # Decorate a cooperator putting all weight on other strategies that are
+        # 'nice'
+        probability = [.3, .2, 0]
+        strategies = [axelrod.TitForTat, axelrod.Grudger, axelrod.Defector]
+        MD = MixedTransformer(probability, strategies)(axelrod.Cooperator)
+
+        p1 = MD()
+        # Against a cooperator we see that we only cooperate
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [C, C, C, C, C])
+
+        # Decorate a cooperator putting all weight on Defector
+        probability = (0, 0, 1)  # Note can also pass tuple
+        strategies = [axelrod.TitForTat, axelrod.Grudger, axelrod.Defector]
+        MD = MixedTransformer(probability, strategies)(axelrod.Cooperator)
+
+        p1 = MD()
+        # Against a cooperator we see that we only cooperate
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [D, D, D, D, D])
+
     def test_deadlock(self):
         """Test the DeadlockBreakingTransformer."""
         # We can induce a deadlock by alterting TFT to defect first

docs/tutorials/advanced/strategy_transformers.rst

@@ -132,6 +132,23 @@ after two consequtive rounds of `(D, C)`::
     >>> from axelrod.strategy_transformers import TrackHistoryTransformer
     >>> player = TrackHistoryTransformer(axelrod.Random)()
 
+* :code:`MixedTransformer`: Randomly plays a mutation to another strategy (or
+  set of strategies. Here is the syntax to do this with a set of strategies::
+
+    >>> import axelrod
+    >>> from axelrod.strategy_transformers import MixedTransformer
+    >>> strategies = [axelrod.Grudger, axelrod.TitForTat]
+    >>> probability = [.2, .3]  # .5 chance of mutated to one of above
+    >>> player =  MixedTransformer(probability, strategies)(axelrod.Cooperator)
+
+  Here is the syntax when passing a single strategy::
+
+    >>> import axelrod
+    >>> from axelrod.strategy_transformers import MixedTransformer
+    >>> strategy = axelrod.Grudger
+    >>> probability = .2
+    >>> player =  MixedTransformer(probability, strategy)(axelrod.Cooperator)
+
 
 Composing Transformers
 ----------------------

docs/tutorials/further_topics/classification_of_strategies.rst

@@ -24,7 +24,7 @@ This allows us to, for example, quickly identify all the stochastic
 strategies::
 
     >>> len([s for s in axl.strategies if s().classifier['stochastic']])
-    36
+    37
 
 Or indeed find out how many strategy only use 1 turn worth of memory to
 make a decision::
@@ -37,13 +37,13 @@ tournament. For example, here is the number of strategies that  make use of the
 length of each match of the tournament::
 
     >>> len([s() for s in axl.strategies if 'length' in s().classifier['makes_use_of']])
-    8
+    9
 
 Here are how many of the strategies that make use of the particular game being
 played (whether or not it's the default Prisoner's dilemma)::
 
     >>> len([s() for s in axl.strategies if 'game' in s().classifier['makes_use_of']])
-    20
+    21
 
 Similarly, strategies that :code:`manipulate_source`, :code:`manipulate_state`
 and/or :code:`inspect_source` return :code:`False` for the :code:`obey_axelrod`