refactor simple opponents out of players file

Author: evolvingstuff

src/players.py

@@ -22,89 +22,6 @@ def get_dim_generic(parameter_groups):
     return total
 
 
-class ConstantPlayer():
-    """
-    Always play same move
-    """
-    def __init__(self, constant_choice):
-        self.constant_choice = constant_choice
-
-    def move(self, last_opponent_action):
-        return self.constant_choice
-
-
-class RandomStrategyChangePlayer():
-    """
-    Switches strategy with probability p
-    """
-    def __init__(self, p=0.1):
-        self.p = p
-        self.choice = random.randint(0, 2)
-
-    def move(self, last_opponent_action):
-        if random.random() < self.p:
-            self.choice = random.randint(0, 2)
-        return self.choice
-
-
-class RoundRobinPlayer():
-    """
-    Rock, paper, scissors, rock, paper, scissors, ...
-    """
-    def __init__(self):
-        self.choice = random.randint(0, 2)
-        self.update_rule = random.choice([-1, 1])
-
-    def move(self, last_opponent_action):
-        self.choice += self.update_rule  # be able to cycle both directions
-        self.choice = self.choice % 3
-        return self.choice
-
-
-class ReverseRoundRobinDoubleTapPlayer():
-    """
-    Rock, rock, scissors, scissors, paper, paper, ...
-    """
-    def __init__(self):
-        self.random_offset = random.randint(0, 5)
-        self.pattern = [0, 0, 2, 2, 1, 1]
-        self.round_num = 0
-
-    def move(self, last_opponent_action):
-        choice = self.pattern[(self.round_num + self.random_offset)% len(self.pattern)]
-        self.round_num += 1
-        return choice
-
-
-class RandomPlayer():
-    """
-    The classic Nash equilibrium strategy that cannot be exploited
-    if we assume symmetrical rewards.
-    """
-    def move(self, last_opponent_action):
-        return random.randint(0, 2)
-
-
-class BiasedRandomPlayer():
-    """
-    Similar to the RandomPlayer, but can learn to stochastically favor
-    certain actions more than others
-    """
-    def __init__(self):
-        self.bias = None
-
-    def get_dim(self):
-        return 3
-
-    def set_parameters(self, x: torch.Tensor):
-        self.bias = x
-
-    def move(self, last_opponent_action):
-        softmax_output = F.softmax(self.bias)
-        choice = torch.multinomial(softmax_output, 1).item()
-        return choice
-
-
 class Rnn():
     """
     A very simple one layer LSTM with a (configurable) argmax or softmax