Merge pull request #344 from marcharper/hunters

New Strategies -- CycleHunter and multiple Meta strategies

Author: meatballs

axelrod/strategies/__init__.py

@@ -5,8 +5,16 @@
 # Now import the Meta strategies. This cannot be done in _strategies
 # because it creates circular dependencies
 
-from .meta import MetaMajority, MetaMinority, MetaWinner, MetaHunter
-strategies.extend((MetaHunter, MetaMajority, MetaMinority, MetaWinner))
+from .meta import (
+    MetaPlayer, MetaMajority, MetaMinority, MetaWinner, MetaHunter,
+    MetaMajorityMemoryOne, MetaWinnerMemoryOne, MetaMajorityFiniteMemory,
+    MetaWinnerFiniteMemory, MetaMajorityLongMemory, MetaWinnerLongMemory
+    )
+
+strategies.extend((MetaHunter, MetaMajority, MetaMinority, MetaWinner,
+                   MetaMajorityMemoryOne, MetaWinnerMemoryOne,
+                   MetaMajorityFiniteMemory, MetaWinnerFiniteMemory,
+                   MetaMajorityLongMemory, MetaWinnerLongMemory))
 
 # Distinguished strategy collections in addition to
 # `strategies` from _strategies.py

axelrod/strategies/_strategies.py

@@ -19,8 +19,8 @@
 from .grudger import Grudger, ForgetfulGrudger, OppositeGrudger, Aggravater
 from .grumpy import Grumpy
 from .hunter import (
-    DefectorHunter, CooperatorHunter, AlternatorHunter, MathConstantHunter,
-    RandomHunter)
+    DefectorHunter, CooperatorHunter, CycleHunter, AlternatorHunter,
+    MathConstantHunter, RandomHunter, EventualCycleHunter)
 from .inverse import Inverse
 from .mathematicalconstants import Golden, Pi, e
 from .memoryone import (
@@ -59,6 +59,7 @@
     Champion,
     Cooperator,
     CooperatorHunter,
+    CycleHunter,
     CyclerCCCCCD,
     CyclerCCCD,
     CyclerCCD,
@@ -68,6 +69,7 @@
     DefectorHunter,
     DoubleCrosser,
     Eatherley,
+    EventualCycleHunter,
     Feld,
     FoolMeForever,
     FoolMeOnce,

axelrod/strategies/calculator.py

@@ -2,7 +2,7 @@
 
 from axelrod import Player
 from .axelrod_tournaments import Joss
-
+from .hunter import detect_cycle
 
 class Calculator(Player):
     """
@@ -23,20 +23,10 @@ def __init__(self):
         Player.__init__(self)
         self.joss_instance = Joss()
 
-    @staticmethod
-    def detect_cycle(history):
-        """Detects if there is a cycle in the opponent's history."""
-        for i in range(len(history) // 2):
-            cycle = itertools.cycle(history[0: i + 1])
-            cycle_list = list(itertools.islice(cycle, 0, len(history)))
-            if list(history) == cycle_list:
-                return True
-        return False
-
     def strategy(self, opponent):
         turn = len(self.history)
         if turn == 20:
-            self.cycle = self.detect_cycle(opponent.history)
+            self.cycle = detect_cycle(opponent.history)
             return self.extended_strategy(opponent)
         if turn > 20:
             return self.extended_strategy(opponent)

axelrod/strategies/hunter.py

@@ -1,8 +1,36 @@
 from __future__ import absolute_import
 
+import itertools
+
 from axelrod import Player
 
 
+def detect_cycle(history, min_size=1, offset=0):
+    """Detects cycles in the sequence history.
+
+    Parameters
+    ----------
+    history: sequence of C and D
+        The sequence to look for cycles within
+    min_size: int, 1
+        The minimum length of the cycle
+    offset: int, 0
+        The amount of history to skip initially
+    """
+    history_tail = history[-offset:]
+    for i in range(min_size, len(history_tail) // 2):
+        cycle = tuple(history_tail[:i])
+        for j in range(len(history_tail)):
+            if history_tail[j] != cycle[j % len(cycle)]:
+                break
+        if j == len(history_tail) - 1:
+            # We made it to the end, is the cycle itself a cycle?
+            # I.E. CCC is not ok as cycle if min_size is really 2
+            # Since this is the same as C
+            return cycle
+    return None
+
+
 class DefectorHunter(Player):
     """A player who hunts for defectors."""
 
@@ -58,6 +86,51 @@ def strategy(self, opponent):
         return 'C'
 
 
+class CycleHunter(Player):
+    """Hunts strategies that play cyclically, like any of the Cyclers,
+    Alternator, etc."""
+
+    name = 'Cycle Hunter'
+    classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    @staticmethod
+    def strategy(opponent):
+        cycle = detect_cycle(opponent.history, min_size=2)
+        if cycle:
+            if len(set(cycle)) > 1:
+                return 'D'
+        return 'C'
+
+
+class EventualCycleHunter(Player):
+    """Hunts strategies that eventually play cyclically"""
+
+    name = 'Eventual Cycle Hunter'
+    classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def strategy(self, opponent):
+        if len(opponent.history) < 10:
+            return 'C'
+        if len(opponent.history) == opponent.cooperations:
+            return 'C'
+        if detect_cycle(opponent.history, offset=15):
+            return 'D'
+        else:
+            return 'C'
+
+
 class MathConstantHunter(Player):
     """A player who hunts for mathematical constant players."""
 

axelrod/strategies/meta.py

@@ -1,7 +1,7 @@
 from axelrod import Player, obey_axelrod
 from ._strategies import strategies
-from .hunter import DefectorHunter, AlternatorHunter, RandomHunter, MathConstantHunter
-
+from .hunter import DefectorHunter, AlternatorHunter, RandomHunter, MathConstantHunter, CycleHunter, EventualCycleHunter
+from .cooperator import Cooperator
 
 # Needs to be computed manually to prevent circular dependency
 ordinary_strategies = [s for s in strategies if obey_axelrod(s)]
@@ -10,7 +10,9 @@
 class MetaPlayer(Player):
     """A generic player that has its own team of players."""
 
-    team = []
+    name = "Meta Player"
+
+    team = [Cooperator]
     classifier = {
         'memory_depth': float('inf'),  # Long memory
         'stochastic': False,
@@ -30,9 +32,12 @@ def __init__(self):
         # Initiate all the player in out team.
         self.team = [t() for t in self.team]
 
-        # If the team will have stochastic players, this meta is also stochastic.
-        self.classifier['stochastic'] = (
-            any([t.classifier['stochastic'] for t in self.team]))
+        # This player inherits the classifiers of its team.
+        for key in ['stochastic', 'inspects_source', 'manipulates_source',
+                    'manipulates_state']:
+            self.classifier[key] = (any([t.classifier[key] for t in self.team]))
+        self.classifier['memory_depth'] = max([t.classifier['memory_depth'] for
+                                               t in self.team])
 
     def strategy(self, opponent):
 
@@ -62,9 +67,14 @@ class MetaMajority(MetaPlayer):
 
     name = "Meta Majority"
 
-    def __init__(self):
-        self.team = ordinary_strategies
+    def __init__(self, team=None):
+        if team:
+            self.team = team
+        else:
+            # Needs to be computed manually to prevent circular dependency
+            self.team = ordinary_strategies
         super(MetaMajority, self).__init__()
+        self.init_args = (team,)
 
     def meta_strategy(self, results, opponent):
         if results.count('D') > results.count('C'):
@@ -77,9 +87,14 @@ class MetaMinority(MetaPlayer):
 
     name = "Meta Minority"
 
-    def __init__(self):
-        self.team = ordinary_strategies
+    def __init__(self, team=None):
+        if team:
+            self.team = team
+        else:
+            # Needs to be computed manually to prevent circular dependency
+            self.team = ordinary_strategies
         super(MetaMinority, self).__init__()
+        self.init_args = (team,)
 
     def meta_strategy(self, results, opponent):
         if results.count('D') < results.count('C'):
@@ -116,8 +131,6 @@ def strategy(self, opponent):
         # Update the running score for each player, before determining the next move.
         if len(self.history):
             for player in self.team:
-                pl_C = player.proposed_history[-1] == "C"
-                opp_C = opponent.history[-1] == "C"
                 game = self.tournament_attributes["game"]
                 s = game.scores[(player.proposed_history[-1], opponent.history[-1])][0]
                 player.score += s
@@ -136,6 +149,10 @@ def meta_strategy(self, results, opponent):
         for r, t in zip(results, self.team):
             t.proposed_history.append(r)
 
+        if opponent.defections == 0:
+            # Don't poke the bear
+            return 'C'
+
         return bestresult
 
 
@@ -157,7 +174,7 @@ def __init__(self):
         # to hunters that use defections as cues. However, a really tangible benefit comes from
         # combining Random Hunter and Math Constant Hunter, since together they catch strategies
         # that are lightly randomized but still quite constant (the tricky/suspecious ones).
-        self.team = [DefectorHunter, AlternatorHunter, RandomHunter, MathConstantHunter]
+        self.team = [DefectorHunter, AlternatorHunter, RandomHunter, MathConstantHunter, CycleHunter, EventualCycleHunter]
 
         super(MetaHunter, self).__init__()
 
@@ -175,3 +192,69 @@ def meta_strategy(results, opponent):
             return 'D' if opponent.history[-1:] == ['D'] else 'C'
         else:
             return 'C'
+
+
+class MetaMajorityMemoryOne(MetaMajority):
+    """MetaMajority with the team of Memory One players"""
+
+    name = "Meta Majority Memory One"
+
+    def __init__(self):
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth'] <= 1]
+        super(MetaMajorityMemoryOne, self).__init__(team=team)
+        self.init_args = ()
+
+
+class MetaWinnerMemoryOne(MetaWinner):
+    """MetaWinner with the team of Memory One players"""
+
+    name = "Meta Winner Memory One"
+
+    def __init__(self):
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth'] <= 1]
+        super(MetaWinnerMemoryOne, self).__init__(team=team)
+        self.init_args = ()
+
+
+class MetaMajorityFiniteMemory(MetaMajority):
+    """MetaMajority with the team of Finite Memory Players"""
+
+    name = "Meta Majority Finite Memory"
+    def __init__(self):
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth']
+                < float('inf')]
+        super(MetaMajorityFiniteMemory, self).__init__(team=team)
+        self.init_args = ()
+
+
+class MetaWinnerFiniteMemory(MetaWinner):
+    """MetaWinner with the team of Finite Memory Players"""
+
+    name = "Meta Winner Finite Memory"
+    def __init__(self):
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth']
+                < float('inf')]
+        super(MetaWinnerFiniteMemory, self).__init__(team=team)
+        self.init_args = ()
+
+
+class MetaMajorityLongMemory(MetaMajority):
+    """MetaMajority with the team of Long (infinite) Memory Players"""
+
+    name = "Meta Majority Long Memory"
+    def __init__(self):
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth']
+                == float('inf')]
+        super(MetaMajorityLongMemory, self).__init__(team=team)
+        self.init_args = ()
+
+
+class MetaWinnerLongMemory(MetaWinner):
+    """MetaWinner with the team of Long (infinite) Memory Players"""
+
+    name = "Meta Winner Long Memory"
+    def __init__(self):
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth']
+                == float('inf')]
+        super(MetaWinnerLongMemory, self).__init__(team=team)
+        self.init_args = ()

axelrod/tests/integration/test_tournament.py

@@ -18,17 +18,17 @@ def setUpClass(cls):
         cls.test_repetitions = 5
 
         cls.expected_outcome = [
-            ('Cooperator', [1800, 1800, 1800, 1800, 1800]),
-            ('Defector', [1612, 1612, 1612, 1612, 1612]),
-            ('Grudger', [1999, 1999, 1999, 1999, 1999]),
-            ('Soft Go By Majority', [1999, 1999, 1999, 1999, 1999]),
-            ('Tit For Tat', [1999, 1999, 1999, 1999, 1999])]
+            ('Cooperator', [180, 180, 180, 180, 180]),
+            ('Defector', [172, 172, 172, 172, 172]),
+            ('Grudger', [199, 199, 199, 199, 199]),
+            ('Soft Go By Majority', [199, 199, 199, 199, 199]),
+            ('Tit For Tat', [199, 199, 199, 199, 199])]
         cls.expected_outcome.sort()
 
     def test_full_tournament(self):
         """A test to check that tournament runs with all non cheating strategies."""
         strategies = [strategy() for strategy in axelrod.ordinary_strategies]
-        tournament = axelrod.Tournament(name='test', players=strategies, game=self.game, turns=500, repetitions=2)
+        tournament = axelrod.Tournament(name='test', players=strategies, game=self.game, turns=20, repetitions=2)
         output_of_tournament = tournament.play().results
         self.assertEqual(type(output_of_tournament), dict)
         self.assertEqual(len(output_of_tournament['payoff']), len(strategies))
@@ -38,7 +38,7 @@ def test_serial_play(self):
             name=self.test_name,
             players=self.players,
             game=self.game,
-            turns=200,
+            turns=20,
             repetitions=self.test_repetitions)
         scores = tournament.play().scores
         actual_outcome = sorted(zip(self.player_names, scores))
@@ -49,7 +49,7 @@ def test_parallel_play(self):
             name=self.test_name,
             players=self.players,
             game=self.game,
-            turns=200,
+            turns=20,
             repetitions=self.test_repetitions,
             processes=2)
         scores = tournament.play().scores