Game theory framework, algorithms and game implementations
A game theory framework providing a collection of games, common API and a several game-theoretic algorithms.
The goal of the project is to provide tools for buildng complex games (e.g. board games, with partial information or simultaneous moves), computation of approximate strateges and creating artificial intelligence for such games, and to be a base for robust value learning experiments.
Under active development, looking for ideas and contributors!
- Outcome sampling MCCFR Nash equilibrium computation
- Exact best response and exploitability
- Approximate best response and exploitablity
- Sparse SGD value learning (with values linear in known features)
- Plotting strategy development (see plots for Matching Pennies, Rock-Paper-Scissors, Goofspiel(4))
- General matrix games (normal form games), Rock-paper-scissors, Matching pennies, Prisoner's dilemma, ...
- Goofspiel (GOPS)
- One-card poker, Dice-poker
For an exploration of API in Rust, see GTCogs.
To implement game you define one class derived from
gamegym.Game with the following interface:
class MyRockPaperScissor(PartialInformationGame): ACTIONS = ("rock", "paper", "scissors") def __init__(self): # Set thenumber of players and all game actions super().__init__(2, self.ACTIONS) def initial_state(self) -> StateInfo: # Return node information, here player 0 is active and has all actions. # Note that in this simple game we do not use any game state. return StateInfo.new_player(state=None, player=0, actions=self.ACTIONS) def update_state(self, situation: Situation, action) -> StateInfo: # Return the node information after playing `action` in `situation`. if len(situation.history) == 0: return StateInfo.new_player(state=None, player=1, actions=self.ACTIONS) p1payoff = 1.0 # TODO: compute from `situation`, e.g. from `situation.history` return StateInfo.new_terminal(state=None, payoff=(x, -x)) # Create game instance game = MyRockPaperScissor() # Initial situation s1 = game.start() # Play some actions s2 = game.play(s1, "rock") s3 = s2.play("paper") # alias for game.play(s2, "paper") # See game result assert s3.is_terminal() assert s3.payoff == (-1.0, 1.0)
The available base classes are
(with specialised subclasses
MatrixGame - which would be a better fit for Rock-Paper-Scissors).
The main auxiliary structs common to all games are
StateInfo that contains the information
about the game node itself, and
Situation which additionally contains game history,
accumulated payoffs, the game itself etc.
Game state is any structure the game uses to keep track of the actual game state, e.g. cards in all hands, game board state, map, ... This is not generally visible to players in partial information game, any observations are passed with
observations=(p0_obs, p1_obs, public_obs) to
Release history Release notifications | RSS feed
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.