PokerML

Train poker strategies toward Nash equilibrium through Counterfactual regret minimization, which iteratively computes regrets for unchosen actions and updates play probabilities via regret matching.^[1] (see Counterfactual regret minimization) Evaluate trained strategies by measuring their exploitability against a Local Best Response that tracks opponent ranges via Bayes' rule. (see Counterfactual regret minimization) Experiment with search depth, bet sizing, and range abstractions by modifying configurable parameters like BET_SIZINGS, SEARCH_MAX_DEPTH, and MONTE_CARLO_BASE without changing core solver logic.^[2] Resolve subgames using a depth-limited solver that replaces the full game tree below a threshold with Solver optimization techniques including mutable game state, neural network leaf value estimation, and Numba-compiled regret matching. (see Solver optimization)

Play heads-up poker against a trained CFR bot in real-time through Interactive play and self-play, which includes human-versus-bot gameplay with live solver visualization and bot-versus-bot self-play sessions to detect strategy imbalances.^[3] (see Interactive play and self-play)

• The Counterfactual regret minimization layer implements the core CFR training algorithm, information set tracking, and strategy storage. (see Counterfactual regret minimization)
• The Game state management layer models poker hand state as a GameState object that tracks position, action history, folded/all-in status, and exposes methods to apply actions and compute legal moves. (see Game state management)
• The Interactive play and self-play layer provides CLI entry points for human-versus-bot gameplay and bot-versus-bot duplicate-matched sessions with frequency tracking. (see Interactive play and self-play)
• The Solver optimization layer accelerates solving through mutable game state, neural network leaf value estimation, and Numba-compiled numerical routines. (see Solver optimization)
• The Legacy card utilities layer provides card representation conversion, poker hand generation, suit abstraction functions, and preflop equity lookup tables. (see Legacy card utilities)

• Game state transitions in Game state management call determine_winners() from cfr/evaluator.py to resolve hands at showdown and update pot calculations via GameState._calculate_side_pots() in cfr/game_state.py.^[4]
• Training a strategy in Counterfactual regret minimization flows from train.py through CFRTrainer.train(), which constructs FastState objects and applies action abstractions to iterate the regret minimization loop.^[5]
• Playing a hand in Interactive play and self-play starts with GameState from Game state management, calls SubgameSolver.solve() from Solver optimization at decision points, and loads strategy to recommend actions.^[6]
• Self-play creates game states via Game state management, applies bot actions through a Bot instance that loads strategy and calls SubgameSolver, and tracks frequencies to measure strategy balance.^[7]

• Counterfactual regret minimization depends on Game state management for game state objects and action legality, importing GameState and get_position_name from cfr/game_state.py and using it throughout training.^[8]
• Counterfactual regret minimization depends on Solver optimization for mutable state representation, importing FastState and action encoding utilities from cfr/fast_state.py to serialize strategies during training.^[9]
• Counterfactual regret minimization depends on Interactive play and self-play for strategy persistence, calling load_strategy() and save_strategy() from cfr/strategy_store.py to resume training and store results.^[10]
• Solver optimization depends on Counterfactual regret minimization for blueprint strategy data and action abstractions, importing InfoSet, card abstractions, and action utilities from cfr/ modules.^[11][12]
• Solver optimization depends on Game state management for game constants and action translation, importing STARTING_STACK, SMALL_BLIND, and action-to-chip conversion from cfr/game_state.py.^[13][14]
• Interactive play and self-play depends on Game state management for game state construction and action validation, importing GameState, STARTING_STACK, and get_position_name to manage live gameplay.^[15]
• Interactive play and self-play depends on Counterfactual regret minimization for strategy loading and exploitation evaluation, importing card abstractions and strategy utilities from cfr/ modules.^[16][17]
• Interactive play and self-play depends on Solver optimization for real-time subgame resolution, importing SubgameSolver from cfr/subgame_solver.py to compute optimal plays during live games.^[18]
• Game state management depends on Counterfactual regret minimization for action legality and evaluation, calling determine_winners() from cfr/evaluator.py to resolve showdowns.^[19]
• Game state management depends on Legacy card utilities for card number-to-text conversion, calling CardUtils.numToCard() in server/game_manager.py to render cards to players.^[20][21]
• Game state management depends on Solver optimization for subgame solving, importing SubgameSolver from cfr/subgame_solver.py in server/bot.py to resolve real-time decisions.^[22]
• Solver optimization and Interactive play and self-play both depend on trained strategy files stored via Counterfactual regret minimization, calling load_strategy() to retrieve serialized blueprint strategies for solving and gameplay.^[23][24]