Add Momentum strategy

Author: dongwonmoon

axelrod/strategies/momentum.py

@@ -0,0 +1,64 @@
+from axelrod.action import Action
+from axelrod.player import Player
+
+C, D = Action.C, Action.D
+
+
+class Momentum(Player):
+    """
+    This strategy is inspired by the concept of Gradual and the mathematical foundation of
+    the Momentum optimizer used in deep learning.
+
+    The idea is that trust (or cooperation) evolves dynamically. A shift in trust can
+    create significant and rapid changes in the player's behavior, much like how momentum
+    responds to gradients in optimization.
+
+    Names:
+     - Momentum: Original name by Dong Won Moon
+
+    Notes:
+     - While I am an undergraduate student with limited experience in game theory, I
+       believe this strategy has potential in various scenarios.
+     - I encourage experts to explore and extend this idea in other contexts, such as
+       environments with noise, one-hot vectorization approaches at multiple actions.
+
+    """
+
+    name = "Momentum"
+    classifier = {
+        "memory_depth": float("inf"),
+        "stochastic": False,
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def __init__(
+        self,
+        alpha=0.9914655399877477,  # Optimized by Genetic Algorithm. You can try to adapt it to any Env.
+        threshold=0.9676595613724907, # This one too
+    ) -> None:
+        super().__init__()
+        self.alpha = alpha
+        self.threshold = threshold
+        self.momentum = 1.0
+
+    def __repr__(self):
+        return f"Momentum: {self.alpha}, {self.threshold}"
+
+    def update_momentum(self, opponent_action):
+        action_value = 1 if opponent_action == C else 0
+        # If the opponent defects, the momentum decreases, reflecting a loss of trust.
+        self.momentum = (
+            self.alpha * self.momentum + (1 - self.alpha) * action_value
+        )
+
+    def strategy(self, opponent: Player) -> Action:
+        if len(self.history) == 0:
+            self.momentum = 1.0
+            return C
+
+        else:
+            self.update_momentum(opponent.history[-1])
+            return C if self.momentum >= self.threshold else D

axelrod/tests/strategies/test_momentum.py

@@ -0,0 +1,99 @@
+import axelrod as axl
+from axelrod import Action
+from axelrod.tests.strategies.test_player import TestPlayer
+from axelrod.strategies.momentum import Momentum
+
+C, D = Action.C, Action.D
+
+class TestMomentum(TestPlayer):
+    name = "Momentum"
+    player = Momentum
+    expected_classifier = {
+        "memory_depth": float("inf"),
+        "stochastic": False,
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def test_initialisation(self):
+        player = self.player(alpha=0.9, threshold=0.8)
+        self.assertEqual(player.alpha, 0.9)
+        self.assertEqual(player.threshold, 0.8)
+        self.assertEqual(player.momentum, 1.0)
+
+    def test_repr(self):
+        player = self.player(alpha=0.9, threshold=0.8)
+        self.assertEqual(repr(player), "Momentum: 0.9, 0.8")
+
+    def test_strategy(self):
+        actions = [(C, C)]
+        self.versus_test(
+            axl.MockPlayer(actions=[C]),
+            expected_actions=actions,
+            init_kwargs={"alpha": 0.5,
+                         "threshold": 0.5
+                         },
+            attrs={"momentum": 1.0}
+        )
+        
+        actions = [(C, D), (C, D), (D, D)]
+        self.versus_test(
+            axl.MockPlayer(actions=[D]),
+            expected_actions=actions,
+            init_kwargs={"alpha": 0.5,
+                         "threshold": 0.5
+                         },
+            attrs={"momentum": 0.25}
+        )
+    
+    def test_vs_alternator(self):
+        actions = [(C, C), (C, D), (C, C), (C, D), (D, C)]
+        self.versus_test(axl.Alternator(), 
+                         expected_actions=actions, 
+                         init_kwargs={"alpha": 0.5,
+                                "threshold": 0.5
+            },
+        )
+
+    def test_vs_cooperator(self):
+        actions = [(C, C), (C, C), (C, C), (C, C), (C, C)]
+        self.versus_test(axl.Cooperator(), 
+                         expected_actions=actions, 
+                         init_kwargs={"alpha": 0.5,
+                                "threshold": 0.5
+            },
+        )
+
+    def test_vs_defector(self):
+        actions = [(C, D), (C, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axl.Defector(), 
+                         expected_actions=actions, 
+                         init_kwargs={"alpha": 0.5,
+                                "threshold": 0.5
+            },
+        )
+
+    def test_vs_random(self):
+        # We can also test against random strategies
+        actions = [(C, D), (C, C), (C, C), (C, D), (D, D)]
+        self.versus_test(axl.Random(), 
+                         expected_actions=actions, 
+                         seed=17,
+                         init_kwargs={"alpha": 0.5,
+                                "threshold": 0.5
+            },
+        )
+
+    def test_vs_random2(self):
+        actions = [(C, C), (C, C), (C, C), (C, C)]
+        self.versus_test(axl.Random(), 
+                         expected_actions=actions, 
+                         seed=3,
+                         init_kwargs={"alpha": 0.5,
+                                "threshold": 0.5
+            },
+        )
+
+