def __init__(
self, num_features: int, num_hidden: int,
weights: List[float] = None
) -> None:
Player.__init__(self)
self.num_features = num_features
self.num_hidden = num_hidden
self._process_weights(weights, num_features, num_hidden)
def __init__(self,
transitions: Tuple[Transition,
...] = ((1, C, 1, C), (1, D, 1, D)),
initial_state: int = 1,
initial_action: Action = C) -> None:
Player.__init__(self)
self.initial_state = initial_state
self.initial_action = initial_action
self.fsm = SimpleFSM(transitions, initial_state)
def __init__(self, cycle: str = "CCD") -> None:
"""This strategy will repeat the parameter `cycle` endlessly,
e.g. C C D C C D C C D ...
Special Cases
-------------
Cooperator is equivalent to Cycler("C")
Defector is equivalent to Cycler("D")
Alternator is equivalent to Cycler("CD")
"""
Player.__init__(self)
self.cycle = cycle
self.set_cycle(cycle=cycle)
def __init__(
self,
lookup_dict: dict = None,
initial_actions: tuple = None,
pattern: Any = None, # pattern is str or tuple of Action's.
parameters: Plays = None) -> None:
Player.__init__(self)
self.parameters = parameters
self.pattern = pattern
self._lookup = self._get_lookup_table(lookup_dict, pattern, parameters)
self._set_memory_depth()
self.initial_actions = self._get_initial_actions(initial_actions)
self._initial_actions_pool = list(self.initial_actions)
def __init__(self,
transitions_C=None,
transitions_D=None,
emission_probabilities=None,
initial_state=0,
initial_action=C) -> None:
Player.__init__(self)
if not transitions_C:
transitions_C = [[1]]
transitions_D = [[1]]
emission_probabilities = [0.5] # Not stochastic
initial_state = 0
self.initial_state = initial_state
self.initial_action = initial_action
self.hmm = SimpleHMM(copy_lists(transitions_C),
copy_lists(transitions_D),
list(emission_probabilities), initial_state)
assert self.hmm.is_well_formed()
self.state = self.hmm.state
self.classifier["stochastic"] = self.is_stochastic()
