Merge pull request #1036 from Axelrod-Python/tfx

Add strategies TF1, TF2, and TF3

Author: drvinceknight

axelrod/strategies/_strategies.py

@@ -22,7 +22,7 @@
 from .finite_state_machines import (
     Fortress3, Fortress4, Predator, Pun1, Raider, Ripoff, SolutionB1,
     SolutionB5, Thumper, FSMPlayer, EvolvedFSM4, EvolvedFSM16,
-    EvolvedFSM16Noise05)
+    EvolvedFSM16Noise05, TF1, TF2, TF3)
 from .forgiver import Forgiver, ForgivingTitForTat
 from .geller import Geller, GellerCooperator, GellerDefector
 from .gambler import (
@@ -238,6 +238,9 @@
     StochasticWSLS,
     SuspiciousTitForTat,
     Tester,
+    TF1,
+    TF2,
+    TF3,
     ThueMorse,
     ThueMorseInverse,
     Thumper,

axelrod/strategies/finite_state_machines.py

@@ -571,3 +571,128 @@ def __init__(self) -> None:
         )
 
         super().__init__(transitions=transitions, initial_state=0, initial_action=C)
+
+
+## Strategies trained with Moran process objectives
+
+
+class TF1(FSMPlayer):
+    """
+    A FSM player trained to maximize Moran fixation probabilities.
+
+    Names:
+
+        - TF1: Original name by Marc Harper
+    """
+
+    name = "TF1"
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def __init__(self) -> None:
+        transitions = (
+            (0, C, 7, C), (0, D, 1, C),
+            (1, C, 11, D), (1, D, 11, D),
+            (2, C, 8, D), (2, D, 8, C),
+            (3, C, 3, C), (3, D, 12, D),
+            (4, C, 6, C), (4, D, 3, C),
+            (5, C, 11, C), (5, D, 8, D),
+            (6, C, 13, D), (6, D, 14, C),
+            (7, C, 4, D), (7, D, 2, D),
+            (8, C, 14, D), (8, D, 8, D),
+            (9, C, 0, C), (9, D, 10, D),
+            (10, C, 8, C), (10, D, 15, C),
+            (11, C, 6, D), (11, D, 5, D),
+            (12, C, 6, D), (12, D, 9, D),
+            (13, C, 9, D), (13, D, 8, D),
+            (14, C, 8, D), (14, D, 13, D),
+            (15, C, 4, C), (15, D, 5, C)
+        )
+
+        super().__init__(transitions=transitions, initial_state=0,
+                         initial_action=C)
+
+
+class TF2(FSMPlayer):
+    """
+    A FSM player trained to maximize Moran fixation probabilities.
+
+    Names:
+
+        - TF2: Original name by Marc Harper
+    """
+
+    name = "TF2"
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def __init__(self) -> None:
+        transitions = (
+            (0, C, 13, D), (0, D, 12, D),
+            (1, C, 3, D), (1, D, 4, D),
+            (2, C, 14, D), (2, D, 9, D),
+            (3, C, 0, C), (3, D, 1, D),
+            (4, C, 1, D), (4, D, 2, D),
+            (7, C, 12, D), (7, D, 2, D),
+            (8, C, 7, D), (8, D, 9, D),
+            (9, C, 8, D), (9, D, 0, D),
+            (10, C, 2, C), (10, D, 15, C),
+            (11, C, 7, D), (11, D, 13, D),
+            (12, C, 3, C), (12, D, 8, D),
+            (13, C, 7, C), (13, D, 10, D),
+            (14, C, 10, D), (14, D, 7, D),
+            (15, C, 15, C), (15, D, 11, D)
+        )
+
+        super().__init__(transitions=transitions, initial_state=0,
+                         initial_action=C)
+
+
+class TF3(FSMPlayer):
+    """
+    A FSM player trained to maximize Moran fixation probabilities.
+
+    Names:
+
+        - TF3: Original name by Marc Harper
+    """
+
+    name = "TF3"
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def __init__(self) -> None:
+        transitions = (
+            (0, C, 0, C), (0, D, 3, C),
+            (1, C, 5, D), (1, D, 0, C),
+            (2, C, 3, C), (2, D, 2, D),
+            (3, C, 4, D), (3, D, 6, D),
+            (4, C, 3, C), (4, D, 1, D),
+            (5, C, 6, C), (5, D, 3, D),
+            (6, C, 6, D), (6, D, 6, D),
+            (7, C, 7, D), (7, D, 5, C)
+        )
+
+        super().__init__(transitions=transitions, initial_state=0,
+                         initial_action=C)

axelrod/tests/strategies/test_finite_state_machines.py

@@ -66,16 +66,18 @@ def test_bad_transitions_raise_error(self):
 
     def test_bad_initial_state_raises_error(self):
         self.assertRaises(ValueError, SimpleFSM,
-                          transitions=self.two_state_transition, initial_state=5)
+                          transitions=self.two_state_transition,
+                          initial_state=5)
 
     def test_state_setter_raises_error_for_bad_input(self):
         with self.assertRaises(ValueError) as cm:
             self.two_state.state = 5
         error_msg = cm.exception.args[0]
-        self.assertEqual(error_msg, 'state: 5 does not have values for both C and D')
+        self.assertEqual(error_msg,
+                         'state: 5 does not have values for both C and D')
 
 
-class TestFSMPlayer(TestPlayer):
+class TestSampleFSMPlayer(TestPlayer):
     """Test a few sample tables to make sure that the finite state machines are
     working as intended."""
 
@@ -98,7 +100,8 @@ def test_cooperator(self):
         cooperator_init_kwargs = {'transitions': ((1, C, 1, C), (1, D, 1, C)),
                                   'initial_state': 1,
                                   'initial_action': C}
-        self.versus_test(axelrod.Alternator(), expected_actions=[(C, C), (C, D)] * 5,
+        self.versus_test(axelrod.Alternator(),
+                         expected_actions=[(C, C), (C, D)] * 5,
                          init_kwargs=cooperator_init_kwargs)
 
     def test_defector(self):
@@ -107,7 +110,8 @@ def test_defector(self):
         defector_init_kwargs = {'transitions': ((1, C, 1, D), (1, D, 1, D)),
                                 'initial_state': 1,
                                 'initial_action': D}
-        self.versus_test(axelrod.Alternator(), expected_actions=[(D, C), (D, D)] * 5,
+        self.versus_test(axelrod.Alternator(),
+                         expected_actions=[(D, C), (D, D)] * 5,
                          init_kwargs=defector_init_kwargs)
 
     def test_tft(self):
@@ -132,7 +136,7 @@ def test_wsls(self):
                          init_kwargs=wsls_init_kwargs)
 
 
-class TestFsmTransitions(TestPlayer):
+class TestFSMPlayer(TestPlayer):
     name = "FSM Player: ((1, 'C', 1, 'C'), (1, 'D', 1, 'D')), 1, C"
     player = axelrod.FSMPlayer
 
@@ -169,10 +173,11 @@ def transitions_test(self, state_and_action):
             expected_actions.append((fsm_move, current_opponent_move))
             opponent_actions.append(current_opponent_move)
 
-            self.verify_against_finite_state_machine(current_state=current_state,
-                                                     expected_state=new_state,
-                                                     last_opponent_move=last_opponent_move,
-                                                     expected_move=fsm_move)
+            self.verify_against_finite_state_machine(
+                current_state=current_state,
+                expected_state=new_state,
+                last_opponent_move=last_opponent_move,
+                expected_move=fsm_move)
 
         self.versus_test(axelrod.MockPlayer(actions=opponent_actions),
                          expected_actions=expected_actions)
@@ -219,7 +224,7 @@ def test_strategy(self):
                          init_kwargs={"transitions": transitions})
 
 
-class TestFortress3(TestFsmTransitions):
+class TestFortress3(TestFSMPlayer):
 
     name = "Fortress3"
     player = axelrod.Fortress3
@@ -259,7 +264,7 @@ def test_incorrect_transitions(self):
         self.transitions_test(state_and_actions)
 
 
-class TestFortress4(TestFsmTransitions):
+class TestFortress4(TestFSMPlayer):
 
     name = "Fortress4"
     player = axelrod.Fortress4
@@ -299,7 +304,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestPredator(TestFsmTransitions):
+class TestPredator(TestFSMPlayer):
 
     name = "Predator"
     player = axelrod.Predator
@@ -350,7 +355,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestPun1(TestFsmTransitions):
+class TestPun1(TestFSMPlayer):
 
     name = "Pun1"
     player = axelrod.Pun1
@@ -380,7 +385,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestRaider(TestFsmTransitions):
+class TestRaider(TestFSMPlayer):
 
     name = "Raider"
     player = axelrod.Raider
@@ -420,7 +425,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestRipoff(TestFsmTransitions):
+class TestRipoff(TestFSMPlayer):
 
     name = "Ripoff"
     player = axelrod.Ripoff
@@ -455,7 +460,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestSolutionB1(TestFsmTransitions):
+class TestSolutionB1(TestFSMPlayer):
 
     name = "SolutionB1"
     player = axelrod.SolutionB1
@@ -488,7 +493,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestSolutionB5(TestFsmTransitions):
+class TestSolutionB5(TestFSMPlayer):
 
     name = "SolutionB5"
     player = axelrod.SolutionB5
@@ -533,7 +538,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestThumper(TestFsmTransitions):
+class TestThumper(TestFSMPlayer):
 
     name = "Thumper"
     player = axelrod.Thumper
@@ -563,7 +568,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestEvolvedFSM4(TestFsmTransitions):
+class TestEvolvedFSM4(TestFSMPlayer):
 
     name = "Evolved FSM 4"
     player = axelrod.EvolvedFSM4
@@ -601,7 +606,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestEvolvedFSM16(TestFsmTransitions):
+class TestEvolvedFSM16(TestFSMPlayer):
 
     name = "Evolved FSM 16"
     player = axelrod.EvolvedFSM16
@@ -693,7 +698,7 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
-class TestEvolvedFSM16Noise05(TestFsmTransitions):
+class TestEvolvedFSM16Noise05(TestFSMPlayer):
 
     name = "Evolved FSM 16 Noise 05"
     player = axelrod.EvolvedFSM16Noise05
@@ -780,3 +785,60 @@ def test_strategy(self):
         # finished 0, 1, 2, 3, 4, 5, 6, 8, 10, 11, 12, 13, 14, 15
         state_and_actions = to_state_eleven + [(11, C), (14, D)] + [(13, C)] * 3
         self.transitions_test(state_and_actions)
+
+
+class TestTF1(TestFSMPlayer):
+    name = "TF1"
+    player = axelrod.TF1
+    expected_classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        self.first_play_test(C)
+        actions = [(C, C), (C, D), (D, C), (D, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions)
+
+
+class TestTF2(TestFSMPlayer):
+    name = "TF2"
+    player = axelrod.TF2
+    expected_classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        self.first_play_test(C)
+        actions = [(C, C), (D, D), (D, C), (C, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions)
+
+
+class TestTF3(TestFSMPlayer):
+    name = "TF3"
+    player = axelrod.TF3
+    expected_classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        self.first_play_test(C)
+        actions = [(C, C), (C, D), (C, C), (D, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions)