noregret 0.0.0.dev4__tar.gz → 0.0.0.dev5__tar.gz

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev4
+Version: 0.0.0.dev5
 Summary: No-regret learning dynamics
 Home-page: https://github.com/uoftcprg/noregret
 Author: Universal, Open, Free, and Transparent Computer Poker Research Group
@@ -94,8 +94,8 @@ The code snippet below demonstrates how one can solve games via regret minimizat
    KERNEL = nr.FloatingPointKernel()
    GAMES = {
        'Rock paper superscissors': nr.to_efg(nr.RockPaperSuperscissors(KERNEL)),
-       'Kuhn poker': nr.from_open_spiel(KERNEL, 'kuhn_poker'),
-       'Leduc poker': nr.from_open_spiel(KERNEL, 'leduc_poker'),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
    }
    PARAMETERS = {
        'CFR': (nr.CFR, False, False),
@@ -180,7 +180,7 @@ The code snippet below demonstrates how one can solve games while leveraging GPU
    import noregret as nr
    
    KERNEL = nr.CUDAKernel()
-   GAME = nr.from_open_spiel(KERNEL, 'liars_dice')
+   GAME = nr.to_efg(KERNEL, nr.from_open_spiel('liars_dice'))
    PARAMETERS = nr.CFR, True, False
    
    
@@ -220,8 +220,8 @@ The code snippet below demonstrates how one can solve games via linear programmi
    KERNEL = nr.FloatingPointKernel()
    GAMES = {
        'Rock paper superscissors': nr.RockPaperSuperscissors(KERNEL),
-       'Kuhn poker': nr.from_open_spiel(KERNEL, 'kuhn_poker'),
-       'Leduc poker': nr.from_open_spiel(KERNEL, 'leduc_poker'),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
    }
    
    
@@ -236,57 +236,6 @@ The code snippet below demonstrates how one can solve games via linear programmi
    if __name__ == '__main__':
        main()
 
-Conduct Research in Online Convex Optimization
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The code snippet below reproduces Leme, Piliouras, and Schneider (NeurIPS, 2024) using NoRegret.
-
-.. code-block:: python
-
-   from functools import partial
-   
-   import matplotlib.pyplot as plt
-   import noregret as nr
-   
-   KERNEL = nr.FloatingPointKernel()
-   GAME = nr.RockPaperScissorsPlus(KERNEL)
-   R_type = partial(nr.MWU, learning_rate=1e-3)
-   
-   
-   def main():
-       RM = R_type(KERNEL, GAME.row_dimension, is_time_symmetric=False)
-       BM_RM = nr.BM(KERNEL, GAME.row_dimension, R_type, is_time_symmetric=False)
-   
-       nr.symmetric_regret_minimization(GAME, RM, iteration_count=100000)
-       nr.symmetric_regret_minimization(GAME, BM_RM, iteration_count=100000)
-       x, _ = nr.linear_programming(GAME)
-   
-       strategies = KERNEL.numpy.array(RM.strategies)
-   
-       plt.clf()
-       plt.plot(strategies[:, 0], strategies[:, 1])
-       plt.plot(strategies[-1, 0], strategies[-1, 1], 'bo')
-       plt.plot(*x[:2], 'ro')
-       plt.xlabel('Probability of action 1')
-       plt.ylabel('Probability of action 2')
-       plt.title('No-external regret dynamics')
-       plt.show()
-   
-       strategies = KERNEL.numpy.array(BM_RM.strategies)
-   
-       plt.clf()
-       plt.plot(strategies[:, 0], strategies[:, 1])
-       plt.plot(strategies[-1, 0], strategies[-1, 1], 'bo')
-       plt.plot(*x[:2], 'ro')
-       plt.xlabel('Probability of action 1')
-       plt.ylabel('Probability of action 2')
-       plt.title('No-swap regret dynamics')
-       plt.show()
-   
-   
-   if __name__ == '__main__':
-       main()
-
 Testing and Validation
 ----------------------
 

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/README.rst

@@ -44,8 +44,8 @@ The code snippet below demonstrates how one can solve games via regret minimizat
    KERNEL = nr.FloatingPointKernel()
    GAMES = {
        'Rock paper superscissors': nr.to_efg(nr.RockPaperSuperscissors(KERNEL)),
-       'Kuhn poker': nr.from_open_spiel(KERNEL, 'kuhn_poker'),
-       'Leduc poker': nr.from_open_spiel(KERNEL, 'leduc_poker'),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
    }
    PARAMETERS = {
        'CFR': (nr.CFR, False, False),
@@ -130,7 +130,7 @@ The code snippet below demonstrates how one can solve games while leveraging GPU
    import noregret as nr
    
    KERNEL = nr.CUDAKernel()
-   GAME = nr.from_open_spiel(KERNEL, 'liars_dice')
+   GAME = nr.to_efg(KERNEL, nr.from_open_spiel('liars_dice'))
    PARAMETERS = nr.CFR, True, False
    
    
@@ -170,8 +170,8 @@ The code snippet below demonstrates how one can solve games via linear programmi
    KERNEL = nr.FloatingPointKernel()
    GAMES = {
        'Rock paper superscissors': nr.RockPaperSuperscissors(KERNEL),
-       'Kuhn poker': nr.from_open_spiel(KERNEL, 'kuhn_poker'),
-       'Leduc poker': nr.from_open_spiel(KERNEL, 'leduc_poker'),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
    }
    
    
@@ -186,57 +186,6 @@ The code snippet below demonstrates how one can solve games via linear programmi
    if __name__ == '__main__':
        main()
 
-Conduct Research in Online Convex Optimization
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The code snippet below reproduces Leme, Piliouras, and Schneider (NeurIPS, 2024) using NoRegret.
-
-.. code-block:: python
-
-   from functools import partial
-   
-   import matplotlib.pyplot as plt
-   import noregret as nr
-   
-   KERNEL = nr.FloatingPointKernel()
-   GAME = nr.RockPaperScissorsPlus(KERNEL)
-   R_type = partial(nr.MWU, learning_rate=1e-3)
-   
-   
-   def main():
-       RM = R_type(KERNEL, GAME.row_dimension, is_time_symmetric=False)
-       BM_RM = nr.BM(KERNEL, GAME.row_dimension, R_type, is_time_symmetric=False)
-   
-       nr.symmetric_regret_minimization(GAME, RM, iteration_count=100000)
-       nr.symmetric_regret_minimization(GAME, BM_RM, iteration_count=100000)
-       x, _ = nr.linear_programming(GAME)
-   
-       strategies = KERNEL.numpy.array(RM.strategies)
-   
-       plt.clf()
-       plt.plot(strategies[:, 0], strategies[:, 1])
-       plt.plot(strategies[-1, 0], strategies[-1, 1], 'bo')
-       plt.plot(*x[:2], 'ro')
-       plt.xlabel('Probability of action 1')
-       plt.ylabel('Probability of action 2')
-       plt.title('No-external regret dynamics')
-       plt.show()
-   
-       strategies = KERNEL.numpy.array(BM_RM.strategies)
-   
-       plt.clf()
-       plt.plot(strategies[:, 0], strategies[:, 1])
-       plt.plot(strategies[-1, 0], strategies[-1, 1], 'bo')
-       plt.plot(*x[:2], 'ro')
-       plt.xlabel('Probability of action 1')
-       plt.ylabel('Probability of action 2')
-       plt.title('No-swap regret dynamics')
-       plt.show()
-   
-   
-   if __name__ == '__main__':
-       main()
-
 Testing and Validation
 ----------------------
 

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/__init__.py

@@ -2,6 +2,7 @@
 from noregret.games import (
     AssuranceGame,
     BattleOfTheSexes,
+    BlackBoxGame,
     Chicken,
     ExtensiveFormGame,
     from_open_spiel,
@@ -36,6 +37,7 @@ from noregret.kernels import (
 from noregret.regret_minimizers import (
     BlumMansour,
     CounterfactualRegretMinimization,
+    CounterfactualRegretMinimization2,
     CounterfactualRegretMinimizationPlus,
     DiscountedCounterfactualRegretMinimization,
     DiscountedRegretMatching,
@@ -65,6 +67,8 @@ BM = BlumMansour
 """Alias for :class:`noregret.BlumMansour`."""
 CFR = CounterfactualRegretMinimization
 """Alias for :class:`noregret.CounterfactualRegretMinimization`."""
+CFR2 = CounterfactualRegretMinimization2
+"""Alias for :class:`noregret.CounterfactualRegretMinimization2`."""
 CFR_plus = CounterfactualRegretMinimizationPlus
 """Alias for :class:`noregret.CounterfactualRegretMinimizationPlus`."""
 DCFR = DiscountedCounterfactualRegretMinimization
@@ -111,12 +115,14 @@ to_efg = to_extensive_form
 __all__ = (
     'AssuranceGame',
     'BattleOfTheSexes',
+    'BlackBoxGame',
     'BlumMansour',
     'BM',
     'CFR',
     'CFR_plus',
     'Chicken',
     'CounterfactualRegretMinimization',
+    'CounterfactualRegretMinimization2',
     'CounterfactualRegretMinimizationPlus',
     'CUDAKernel',
     'DCFR',

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/games/__init__.py

@@ -1,4 +1,5 @@
 """Module for games."""
+from noregret.games.black_box import BlackBoxGame, from_open_spiel
 from noregret.games.extensive_form import (
     ExtensiveFormGame,
     TwoPlayerExtensiveFormGame,
@@ -26,11 +27,12 @@ from noregret.games.normal_form import (
     TwoPlayerNormalFormGame,
     TwoPlayerZeroSumNormalFormGame,
 )
-from noregret.games.utilities import from_open_spiel, to_extensive_form
+from noregret.games.utilities import to_extensive_form
 
 __all__ = (
     'AssuranceGame',
     'BattleOfTheSexes',
+    'BlackBoxGame',
     'Chicken',
     'ExtensiveFormGame',
     'from_open_spiel',

noregret-0.0.0.dev5/noregret/games/black_box.py

@@ -0,0 +1,200 @@
+"""Module for black box games."""
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from functools import partial
+
+from ordered_set import OrderedSet
+from pyspiel import GameType, load_game
+
+
+@dataclass
+class BlackBoxGame(ABC):
+    """Abstract base class for black box games."""
+
+    @property
+    @abstractmethod
+    def player_count(self):
+        """Return the number of players.
+
+        :return: Number of players.
+        """
+
+    @property
+    def is_two_player(self):
+        """Return whether the game is two-player.
+
+        :return: Whether the game is two-player.
+        """
+        return self.player_count == 2
+
+    @property
+    @abstractmethod
+    def is_zero_sum(self):
+        """Return whether the game is zero-sum.
+
+        :return: Whether the game is zero-sum.
+        """
+
+    @property
+    @abstractmethod
+    def root_node(self):
+        """Return the root node.
+
+        :return: Root node.
+        """
+
+    @abstractmethod
+    def actions(self, node):
+        """Return the actions given a node.
+
+        :param node: Node.
+        :return: Actions.
+        """
+
+    @abstractmethod
+    def apply(self, node, action):
+        """Return the child node given a node and an action.
+
+        :param node: Node.
+        :param action: Action.
+        :return: Child node.
+        """
+
+    def children(self, node):
+        """Return the children given a node.
+
+        :return: Children.
+        """
+        return list(map(partial(self.apply, node), self.actions(node)))
+
+    def actions_and_children(self, node):
+        """Return the actions and children given a node.
+
+        :return: Actions and children.
+        """
+        A = self.actions(node)
+
+        return A, list(map(partial(self.apply, node), A))
+
+    @abstractmethod
+    def player(self, node):
+        """Return the player given a node.
+
+        :param node: Node.
+        :return: Player.
+        """
+
+    @abstractmethod
+    def utility(self, player, node):
+        """Return the utility given a player and a node.
+
+        :param player: Player.
+        :param node: Node.
+        :return: Utility.
+        """
+
+    def utilities(self, node):
+        """Return the utilities given a node.
+
+        :param node: Node.
+        :return: Utilities.
+        """
+        P = range(self.player_count)
+
+        return list(map(self.utility(i, node) for i in P))
+
+    @abstractmethod
+    def information_set(self, node):
+        """Return the information set given a node.
+
+        :param node: Node.
+        :return: information set.
+        """
+
+    @abstractmethod
+    def chance_probability(self, node, action):
+        """Return the chance probability given a node and an action.
+
+        :param node: Node.
+        :param action: Action.
+        :return: Chance probability.
+        """
+
+    def chance_probabilities(self, node):
+        """Return the chance probabilities given a node.
+
+        :param node: Node.
+        :return: Chance probabilities.
+        """
+        A = self.actions(node)
+
+        return list(map(self.chance_probability(node, a) for a in A))
+
+
+@dataclass
+class _OpenSpielBlackBoxGame(BlackBoxGame):
+    game: str
+    _game: str = field(init=False)
+
+    def __post_init__(self):
+        self._game = load_game(self.game)
+
+    @property
+    def player_count(self):
+        return self._game.num_players()
+
+    @property
+    def is_zero_sum(self):
+        return self._game.get_type().utility == GameType.Utility.ZERO_SUM
+
+    @property
+    def root_node(self):
+        return self._game.new_initial_state()
+
+    def actions(self, node):
+        return OrderedSet(map(node.action_to_string, node.legal_actions()))
+
+    def apply(self, node, action):
+        return node.child(node.string_to_action(action))
+
+    def children(self, node):
+        return list(node.child(a) for a in node.legal_actions())
+
+    def actions_and_children(self, node):
+        actions = []
+        children = []
+
+        for a in node.legal_actions():
+            actions.append(node.action_to_string(a))
+            children.append(node.child(a))
+
+        return actions, children
+
+    def player(self, node):
+        i = node.current_player()
+
+        return None if i == -1 else i
+
+    def utility(self, player, node):
+        return node.player_reward(player)
+
+    def utilities(self, node):
+        return node.rewards()
+
+    def information_set(self, node):
+        return node.information_state_string()
+
+    def chance_probability(self, node, action):
+        return node.chance_outcomes()[self.actions(node).index(action)][1]
+
+    def chance_probabilities(self, node):
+        return [p for _, p in node.chance_outcomes()]
+
+
+def from_open_spiel(game):
+    """Load a game from OpenSpiel.
+
+    :param game: Game in OpenSpiel.
+    :return: Game.
+    """
+    return _OpenSpielBlackBoxGame(game)

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/games/games.py

@@ -22,6 +22,7 @@ class Game(ABC):
         :return: Number of players.
         """
 
+    @property
     @abstractmethod
     def is_symmetric(self):
         """Return whether the game is symmetric.

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/games/multilinear.py

@@ -39,6 +39,7 @@ class MultilinearGame(Game, ABC):
         """
         return tuple(self.dimension(i) for i in range(self.player_count))
 
+    @property
     def is_symmetric(self):
         raise NotImplementedError
 
@@ -100,6 +101,7 @@ class TwoPlayerMultilinearGame(TwoPlayerGame, MultilinearGame, ABC):
         """
         return self.payoffs[1]
 
+    @property
     def is_symmetric(self):
         np = self.kernel.numpy
 

noregret-0.0.0.dev5/noregret/games/utilities.py

@@ -0,0 +1,140 @@
+from collections import defaultdict
+from functools import partial, singledispatch
+from itertools import starmap
+
+from ordered_set import OrderedSet
+from scipy.sparse import lil_array
+
+from noregret.games.black_box import BlackBoxGame
+from noregret.games.extensive_form.games import (
+    ExtensiveFormGame,
+    TwoPlayerExtensiveFormGame,
+    TwoPlayerZeroSumExtensiveFormGame,
+)
+from noregret.games.games import Game
+from noregret.games.normal_form.games import (
+    NormalFormGame,
+    TwoPlayerNormalFormGame,
+    TwoPlayerZeroSumNormalFormGame,
+)
+from noregret.sequence_form_polytopes import SequenceFormPolytope
+
+
+def _nfg2efg(kernel, game, decision_points=str):
+    np = kernel.numpy
+    scipy = kernel.scipy
+    dtype = kernel.data_type
+
+    if isinstance(game, TwoPlayerZeroSumNormalFormGame):
+        type_ = TwoPlayerZeroSumExtensiveFormGame
+    elif isinstance(game, TwoPlayerNormalFormGame):
+        type_ = TwoPlayerExtensiveFormGame
+    else:
+        type_ = ExtensiveFormGame
+
+    d = game.dimensions
+
+    if isinstance(game, TwoPlayerZeroSumNormalFormGame):
+        payoffs = np.zeros(tuple(n + 1 for n in d), dtype)
+        payoffs[tuple(slice(1, None) for _ in d)] = game.payoffs
+    else:
+        payoffs = np.zeros((game.player_count, *(n + 1 for n in d)), dtype)
+        payoffs[:, *(slice(1, None) for _ in d)] = game.payoffs
+
+    payoffs = scipy.sparse.csr_array(payoffs)
+    sfps = []
+
+    for i, A_j in enumerate(game.actions):
+        j = decision_points(i)
+        sfp = SequenceFormPolytope(kernel, {j: A_j}, {j: None})
+
+        sfps.append(sfp)
+
+    sfps = tuple(sfps)
+
+    return type_(kernel, payoffs, sfps)
+
+
+def _bbg2efg(kernel, game):
+    scipy = kernel.scipy
+    dtype = kernel.data_type
+    P = range(game.player_count)
+    A_js = [defaultdict(OrderedSet) for _ in P]
+    p_js = [{} for _ in P]
+    raw_payoffs = [defaultdict(int) for _ in P]
+
+    def dfs(h, p, seqs, us):
+        A_j, h_primes = game.actions_and_children(h)
+        i = game.player(h)
+        us = us.copy()
+
+        for i_prime, v in enumerate(game.utilities(h)):
+            us[i_prime] += v
+
+        if not A_j:
+            seqs = tuple(seqs)
+
+            for i_prime, u in enumerate(us):
+                raw_payoffs[i_prime][seqs] += p * u
+        elif i is None:
+            p_primes = game.chance_probabilities(h)
+
+            for h_prime, p_prime in zip(h_primes, p_primes):
+                dfs(h_prime, p_prime * p, seqs, us)
+        else:
+            j = game.information_set(h)
+            p_j = seqs[i]
+            p_js[i][j] = p_j
+
+            for a, h_prime in zip(A_j, h_primes):
+                next_seqs = seqs.copy()
+                next_seqs[i] = j, a
+
+                A_js[i][j].add(a)
+                dfs(h_prime, p, next_seqs, us)
+
+    dfs(game.root_node, 1, [None for _ in P], [0 for _ in P])
+
+    SFP = partial(SequenceFormPolytope, kernel)
+    sfps = tuple(starmap(SFP, zip(A_js, p_js)))
+    dimensions = tuple(sfp.column_count for sfp in sfps)
+
+    if game.is_two_player and game.is_zero_sum:
+        type_ = TwoPlayerZeroSumExtensiveFormGame
+        payoffs = lil_array(dimensions, dtype=dtype)
+
+        for seqs, u in raw_payoffs[0].items():
+            indices = []
+
+            for sfp, seq in zip(sfps, seqs):
+                indices.append(sfp.column(seq))
+
+            payoffs[tuple(indices)] = u
+
+        payoffs = scipy.sparse.csr_array(payoffs)
+    else:
+        raise NotImplementedError
+
+    return type_(kernel, payoffs, sfps)
+
+
+@singledispatch
+def to_extensive_form(kernel, game):
+    """Convert a given game to an extensive-form game.
+
+    :param game: Game.
+    :return: Extensive-form game.
+    """
+    if isinstance(game, NormalFormGame):
+        game = _nfg2efg(kernel, game)
+    elif isinstance(game, BlackBoxGame):
+        game = _bbg2efg(kernel, game)
+    else:
+        raise ValueError('unknown game')
+
+    return game
+
+
+@to_extensive_form.register
+def _(game: Game):
+    return to_extensive_form(game.kernel, game)

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/kernels.py

@@ -9,7 +9,6 @@ from noregret.utilities import import_object
 @dataclass(repr=False)
 class Kernel(ABC):
     """Abstract base class for kernels."""
-
     data_type: Any = float
     """Data type."""
     index_type: Any = int

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/regret_minimizers/__init__.py

@@ -19,6 +19,7 @@ from noregret.regret_minimizers.probability_simplices import (
 )
 from noregret.regret_minimizers.sequence_form_polytopes import (
     CounterfactualRegretMinimization,
+    CounterfactualRegretMinimization2,
     CounterfactualRegretMinimizationPlus,
     DiscountedCounterfactualRegretMinimization,
     SequenceFormPolytopeRegretMinimizer,
@@ -27,6 +28,7 @@ from noregret.regret_minimizers.sequence_form_polytopes import (
 __all__ = (
     'BlumMansour',
     'CounterfactualRegretMinimization',
+    'CounterfactualRegretMinimization2',
     'CounterfactualRegretMinimizationPlus',
     'DiscountedCounterfactualRegretMinimization',
     'DiscountedRegretMatching',

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/regret_minimizers/probability_simplices.py

@@ -270,6 +270,8 @@ class BlumMansour(ProbabilitySimplexSwapRegretMinimizer):
     """External regret minimizeres."""
 
     def __post_init__(self):
+        super().__post_init__()
+
         n = self.dimension
         R_type = partial(self.regret_minimizer_type, self.kernel)
         self.external_regret_minimizers = tuple(map(R_type, repeat(n, n)))

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/regret_minimizers/regret_minimizers.py

@@ -38,13 +38,18 @@ class RegretMinimizer(ABC):
     """Strategies."""
     utilities: list[Any] = field(default_factory=list)
     """Utilities."""
-    _next_strategy: Any = None
+    dimension: int = field(init=False)
+    """Dimension."""
+    _next_strategy: Any = field(default=None, init=False)
+
+    def __post_init__(self):
+        pass
 
     @property
     def next_strategy(self):
         """Return the next strategy.
 
-        :return: The next strategy.
+        :return: Next strategy.
         """
         return self._next_strategy
 

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/regret_minimizers/sequence_form_polytopes.py

@@ -5,14 +5,14 @@ from typing import Any
 from abc import ABC
 
 from noregret.regret_minimizers.probability_simplices import (
-    DiscountedRegretMatching,
+    ProbabilitySimplexRegretMinimizer,
     RegretMatching,
-    RegretMatchingPlus,
 )
 from noregret.regret_minimizers.regret_minimizers import (
     DiscountedRegretMinimizer,
     RegretMinimizer,
 )
+from noregret.sequence_form_polytopes import SequenceFormPolytope
 
 
 @dataclass
@@ -20,7 +20,7 @@ class SequenceFormPolytopeRegretMinimizer(RegretMinimizer, ABC):
     """Abstract base class for regret minimizers operating over
     sequence-form polytopes.
     """
-    sequence_form_polytope: Any
+    sequence_form_polytope: SequenceFormPolytope
     """Sequence-form polytope."""
     _: KW_ONLY
     previous_behavioral_strategy: Any = 0.0
@@ -73,8 +73,6 @@ class SequenceFormPolytopeRegretMinimizer(RegretMinimizer, ABC):
 @dataclass
 class CounterfactualRegretMinimization(SequenceFormPolytopeRegretMinimizer):
     """Class for counterfactual regret minimization (CFR)."""
-    regret_minimizer_type: Any = RegretMatching
-    """Regret minimizer type."""
 
     def _theta(self, m):
         np = self.kernel.numpy
@@ -99,11 +97,9 @@ class CounterfactualRegretMinimization(SequenceFormPolytopeRegretMinimizer):
 
     def output(self, prediction=False):
         theta = self._theta(prediction)
-        normalize = self.sequence_form_polytope.normalize
-        self.next_behavioral_strategy = normalize(theta)
-        self.next_strategy = self.sequence_form_polytope.to_sequence_form(
-            self.next_behavioral_strategy,
-        )
+        b = self.sequence_form_polytope.normalize(theta)
+        self.next_behavioral_strategy = b
+        self.next_strategy = self.sequence_form_polytope.to_sequence_form(b)
 
         return self.next_strategy
 
@@ -111,7 +107,6 @@ class CounterfactualRegretMinimization(SequenceFormPolytopeRegretMinimizer):
 @dataclass
 class CounterfactualRegretMinimizationPlus(CounterfactualRegretMinimization):
     """Class for counterfactual regret minimization+ (CFR+)."""
-    regret_minimizer_type: Any = RegretMatchingPlus
     _: KW_ONLY
     floored_cumulative_counterfactual_regrets: Any = 0.0
     """Floored cumulative counterfactual regrets."""
@@ -156,7 +151,6 @@ class DiscountedCounterfactualRegretMinimization(
         DiscountedRegretMinimizer,
 ):
     """Class for discounted counterfactual regret minimization+ (DCFR)."""
-    regret_minimizer_type: Any = DiscountedRegretMatching
     _: KW_ONLY
     discounted_counterfactual_regrets: Any = 0.0
     """Discounted counterfactual regrets."""
@@ -195,3 +189,98 @@ class DiscountedCounterfactualRegretMinimization(
         T = self.iteration_count
         r[r > 0] *= T ** self.alpha / (T ** self.alpha + 1)
         r[r < 0] *= T ** self.beta / (T ** self.beta + 1)
+
+
+@dataclass
+class CounterfactualRegretMinimization2(SequenceFormPolytopeRegretMinimizer):
+    """Class for counterfactual regret minimization (CFR).
+
+    This is an alternative to :class:`CounterfactualRegretMinimization`.
+
+    Do **not** use this class unless it is absolutely necessary.
+
+    Main advantage: Arbitrary local regret minimizers.
+
+    Main disadvantage: **Slow** and unparallelizable.
+    """
+    regret_minimizer_type: type[ProbabilitySimplexRegretMinimizer] = (
+        RegretMatching
+    )
+    """Regret minimizer type."""
+    _: KW_ONLY
+    regret_minimizers: dict[str, ProbabilitySimplexRegretMinimizer] = field(
+        default_factory=dict,
+        init=False,
+    )
+    """Regret minimizers."""
+
+    def __post_init__(self):
+        super().__post_init__()
+
+        R_type = self.regret_minimizer_type
+        A = self.sequence_form_polytope.actions
+        J = self.sequence_form_polytope.decision_points
+
+        for j in J:
+            self.regret_minimizers[j] = R_type(self.kernel, len(A[j]))
+
+    def output(self, prediction=False):
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
+        A = self.sequence_form_polytope.actions
+        J = self.sequence_form_polytope.decision_points
+        seqs = self.sequence_form_polytope.non_empty_sequences
+
+        if prediction is False or prediction is True:
+            predictions = {j: prediction for j in J}
+        else:
+            predictions = {}
+            m = self.sequence_form_polytope.counterfactual_utilities(
+                prediction,
+            )
+
+            for j in J:
+                m_j = []
+
+                for a in A[j]:
+                    m_j.append(m[seqs.index((j, a))])
+
+                predictions[j] = np.array(m_j, dtype)
+
+        b = np.empty(len(seqs), dtype)
+
+        for j, R in self.regret_minimizers.items():
+            x = R.output(predictions[j])
+
+            for a, p in zip(A[j], x):
+                b[seqs.index((j, a))] = p
+
+        self.next_behavioral_strategy = b
+        self.next_strategy = self.sequence_form_polytope.to_sequence_form(b)
+
+        return self.next_strategy
+
+    def observe(self, utility):
+        super().observe(utility)
+
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
+        A = self.sequence_form_polytope.actions
+        J = self.sequence_form_polytope.decision_points
+        seqs = self.sequence_form_polytope.non_empty_sequences
+        u = self.sequence_form_polytope.counterfactual_utilities(
+            self.previous_behavioral_strategy,
+            utility,
+        )
+        counterfactual_utilities = {}
+
+        for j in J:
+            u_j = []
+
+            for a in A[j]:
+                u_j.append(u[seqs.index((j, a))])
+
+            counterfactual_utilities[j] = np.array(u_j, dtype)
+
+        for j, R in self.regret_minimizers.items():
+            R.observe(counterfactual_utilities[j])

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/sequence_form_polytopes.py

@@ -127,13 +127,13 @@ class SequenceFormPolytope:
 
         :return: Non-empty sequences.
         """
-        sequences = OrderedSet()
+        seqs = OrderedSet()
 
         for j in self.decision_points:
             for a in self.actions[j]:
-                sequences.add((j, a))
+                seqs.add((j, a))
 
-        return sequences
+        return seqs
 
     @property
     def row_count(self):

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/solvers/regret_minimization.py

@@ -110,7 +110,7 @@ def symmetric_regret_minimization(
     """
     np = game.kernel.numpy
 
-    if not game.is_symmetric():
+    if not game.is_symmetric:
         raise ValueError('game is asymmetric')
 
     R = regret_minimizer

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/tests/test_games.py

@@ -37,8 +37,8 @@ class ExtensiveFormGameTestCase(TestCase):
         nr.to_efg(nr.RockPaperScissors(KERNEL)),
         nr.to_efg(nr.RockPaperScissorsPlus(KERNEL)),
         nr.to_efg(nr.RockPaperSuperscissors(KERNEL)),
-        nr.from_open_spiel(KERNEL, 'kuhn_poker'),
-        nr.from_open_spiel(KERNEL, 'leduc_poker'),
+        nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+        nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
     )
 
     def test_serialization(self):

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/tests/test_linear_programming.py

@@ -14,8 +14,8 @@ class LinearProgrammingTestCase(TestCase):
         (nr.to_efg(nr.RockPaperScissors(KERNEL)), 0),
         (nr.to_efg(nr.RockPaperScissorsPlus(KERNEL)), 0),
         (nr.to_efg(nr.RockPaperSuperscissors(KERNEL)), 0),
-        (nr.from_open_spiel(KERNEL, 'kuhn_poker'), -1 / 18),
-        (nr.from_open_spiel(KERNEL, 'leduc_poker'), -0.08560642407800048),
+        (nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')), -1 / 18),
+        (nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')), -0.08560642408),
     )
 
     def test_linear_programming(self):

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret/tests/test_regret_minimization.py

@@ -82,7 +82,7 @@ class ProbabilitySimplexRegretMinimizationTestCase(TestCase):
         dtype = self.KERNEL.data_type
 
         for game, value in self.SYMMETRIC_GAME_VALUES:
-            assert game.is_symmetric()
+            assert game.is_symmetric
             assert isinstance(game, nr.NFG_2p0s)
 
             for R_type in self.REGRET_MINIMIZER_TYPES:
@@ -110,8 +110,8 @@ class SequenceFormPolytopeRegretMinimizationTestCase(TestCase):
         (nr.to_efg(nr.RockPaperScissors(KERNEL)), 0),
         (nr.to_efg(nr.RockPaperScissorsPlus(KERNEL)), 0),
         (nr.to_efg(nr.RockPaperSuperscissors(KERNEL)), 0),
-        (nr.from_open_spiel(KERNEL, 'kuhn_poker'), -1 / 18),
-        (nr.from_open_spiel(KERNEL, 'leduc_poker'), -0.08560642407800048),
+        (nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')), -1 / 18),
+        (nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')), -0.08560642408),
     )
     REGRET_MINIMIZION_PARAMETERS = (
         (partial(nr.CFR, KERNEL), False, False),
@@ -150,5 +150,42 @@ class SequenceFormPolytopeRegretMinimizationTestCase(TestCase):
                 self.assertEqual(v.dtype, dtype)
 
 
+class SequenceFormPolytopeRegretMinimization2TestCase(TestCase):
+    KERNEL = nr.FloatingPointKernel()
+    GAMES = (
+        nr.to_efg(nr.MatchingPennies(KERNEL)),
+        nr.to_efg(nr.RockPaperScissors(KERNEL)),
+        nr.to_efg(nr.RockPaperScissorsPlus(KERNEL)),
+        nr.to_efg(nr.RockPaperSuperscissors(KERNEL)),
+        nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+        nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
+    )
+    PLACES = 6
+
+    def test_equivalence(self):
+        for game in self.GAMES:
+            assert isinstance(game, nr.EFG_2p0s)
+
+            x_bar, y_bar = nr.regret_minimization(
+                game,
+                nr.CFR(self.KERNEL, game.row_sequence_form_polytope),
+                nr.CFR(self.KERNEL, game.column_sequence_form_polytope),
+                progress_bar=False,
+            )
+            e = game.exploitability(x_bar, y_bar)
+            v = game.expected_row_utility(x_bar, y_bar)
+            x_bar2, y_bar2 = nr.regret_minimization(
+                game,
+                nr.CFR2(self.KERNEL, game.row_sequence_form_polytope),
+                nr.CFR2(self.KERNEL, game.column_sequence_form_polytope),
+                progress_bar=False,
+            )
+            e2 = game.exploitability(x_bar2, y_bar2)
+            v2 = game.expected_row_utility(x_bar2, y_bar2)
+
+            self.assertAlmostEqual(e, e2, self.PLACES)
+            self.assertAlmostEqual(v, v2, self.PLACES)
+
+
 if __name__ == '__main__':
     main()  # pragma: no cover

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev4
+Version: 0.0.0.dev5
 Summary: No-regret learning dynamics
 Home-page: https://github.com/uoftcprg/noregret
 Author: Universal, Open, Free, and Transparent Computer Poker Research Group
@@ -94,8 +94,8 @@ The code snippet below demonstrates how one can solve games via regret minimizat
    KERNEL = nr.FloatingPointKernel()
    GAMES = {
        'Rock paper superscissors': nr.to_efg(nr.RockPaperSuperscissors(KERNEL)),
-       'Kuhn poker': nr.from_open_spiel(KERNEL, 'kuhn_poker'),
-       'Leduc poker': nr.from_open_spiel(KERNEL, 'leduc_poker'),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
    }
    PARAMETERS = {
        'CFR': (nr.CFR, False, False),
@@ -180,7 +180,7 @@ The code snippet below demonstrates how one can solve games while leveraging GPU
    import noregret as nr
    
    KERNEL = nr.CUDAKernel()
-   GAME = nr.from_open_spiel(KERNEL, 'liars_dice')
+   GAME = nr.to_efg(KERNEL, nr.from_open_spiel('liars_dice'))
    PARAMETERS = nr.CFR, True, False
    
    
@@ -220,8 +220,8 @@ The code snippet below demonstrates how one can solve games via linear programmi
    KERNEL = nr.FloatingPointKernel()
    GAMES = {
        'Rock paper superscissors': nr.RockPaperSuperscissors(KERNEL),
-       'Kuhn poker': nr.from_open_spiel(KERNEL, 'kuhn_poker'),
-       'Leduc poker': nr.from_open_spiel(KERNEL, 'leduc_poker'),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
    }
    
    
@@ -236,57 +236,6 @@ The code snippet below demonstrates how one can solve games via linear programmi
    if __name__ == '__main__':
        main()
 
-Conduct Research in Online Convex Optimization
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The code snippet below reproduces Leme, Piliouras, and Schneider (NeurIPS, 2024) using NoRegret.
-
-.. code-block:: python
-
-   from functools import partial
-   
-   import matplotlib.pyplot as plt
-   import noregret as nr
-   
-   KERNEL = nr.FloatingPointKernel()
-   GAME = nr.RockPaperScissorsPlus(KERNEL)
-   R_type = partial(nr.MWU, learning_rate=1e-3)
-   
-   
-   def main():
-       RM = R_type(KERNEL, GAME.row_dimension, is_time_symmetric=False)
-       BM_RM = nr.BM(KERNEL, GAME.row_dimension, R_type, is_time_symmetric=False)
-   
-       nr.symmetric_regret_minimization(GAME, RM, iteration_count=100000)
-       nr.symmetric_regret_minimization(GAME, BM_RM, iteration_count=100000)
-       x, _ = nr.linear_programming(GAME)
-   
-       strategies = KERNEL.numpy.array(RM.strategies)
-   
-       plt.clf()
-       plt.plot(strategies[:, 0], strategies[:, 1])
-       plt.plot(strategies[-1, 0], strategies[-1, 1], 'bo')
-       plt.plot(*x[:2], 'ro')
-       plt.xlabel('Probability of action 1')
-       plt.ylabel('Probability of action 2')
-       plt.title('No-external regret dynamics')
-       plt.show()
-   
-       strategies = KERNEL.numpy.array(BM_RM.strategies)
-   
-       plt.clf()
-       plt.plot(strategies[:, 0], strategies[:, 1])
-       plt.plot(strategies[-1, 0], strategies[-1, 1], 'bo')
-       plt.plot(*x[:2], 'ro')
-       plt.xlabel('Probability of action 1')
-       plt.ylabel('Probability of action 2')
-       plt.title('No-swap regret dynamics')
-       plt.show()
-   
-   
-   if __name__ == '__main__':
-       main()
-
 Testing and Validation
 ----------------------
 

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/noregret.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ noregret.egg-info/dependency_links.txt
 noregret.egg-info/requires.txt
 noregret.egg-info/top_level.txt
 noregret/games/__init__.py
+noregret/games/black_box.py
 noregret/games/games.py
 noregret/games/multilinear.py
 noregret/games/utilities.py

{noregret-0.0.0.dev4 → noregret-0.0.0.dev5}/setup.py

@@ -4,7 +4,7 @@ from setuptools import find_packages, setup
 
 setup(
     name='noregret',
-    version='0.0.0.dev4',
+    version='0.0.0.dev5',
     description='No-regret learning dynamics',
     long_description=open('README.rst').read(),
     long_description_content_type='text/x-rst',

noregret-0.0.0.dev4/noregret/games/utilities.py

@@ -1,141 +0,0 @@
-from collections import defaultdict
-from functools import partial
-from itertools import starmap
-
-from ordered_set import OrderedSet
-from pyspiel import GameType, load_game
-from scipy.sparse import lil_array
-
-from noregret.games.normal_form.games import (
-    NormalFormGame,
-    TwoPlayerNormalFormGame,
-    TwoPlayerZeroSumNormalFormGame,
-)
-from noregret.games.extensive_form.games import (
-    ExtensiveFormGame,
-    TwoPlayerExtensiveFormGame,
-    TwoPlayerZeroSumExtensiveFormGame,
-)
-from noregret.sequence_form_polytopes import SequenceFormPolytope
-
-
-def _nfg2efg(game, decision_points):
-    kernel = game.kernel
-    np = kernel.numpy
-    scipy = kernel.scipy
-    dtype = kernel.data_type
-
-    if isinstance(game, TwoPlayerZeroSumNormalFormGame):
-        type_ = TwoPlayerZeroSumExtensiveFormGame
-    elif isinstance(game, TwoPlayerNormalFormGame):
-        type_ = TwoPlayerExtensiveFormGame
-    else:
-        type_ = ExtensiveFormGame
-
-    d = game.dimensions
-
-    if isinstance(game, TwoPlayerZeroSumNormalFormGame):
-        payoffs = np.zeros(tuple(n + 1 for n in d), dtype)
-        payoffs[tuple(slice(1, None) for _ in d)] = game.payoffs
-    else:
-        payoffs = np.zeros((game.player_count, *(n + 1 for n in d)), dtype)
-        payoffs[:, *(slice(1, None) for _ in d)] = game.payoffs
-
-    payoffs = scipy.sparse.csr_array(payoffs)
-    sequence_form_polytopes = []
-
-    for i, A_j in enumerate(game.actions):
-        j = decision_points(i)
-        sfp = SequenceFormPolytope(kernel, {j: A_j}, {j: None})
-
-        sequence_form_polytopes.append(sfp)
-
-    sequence_form_polytopes = tuple(sequence_form_polytopes)
-
-    return type_(kernel, payoffs, sequence_form_polytopes)
-
-
-def to_extensive_form(game, decision_points=str):
-    """Convert a given game to an extensive-form game.
-
-    :param game: Game.
-    :param decision_points: Decision points, defaults to ``str''.
-    :return: Extensive-form game.
-    """
-    if isinstance(game, NormalFormGame):
-        game = _nfg2efg(game, decision_points)
-    else:
-        raise ValueError('unknown game')
-
-    return game
-
-
-def from_open_spiel(kernel, game):
-    """Load a game from OpenSpiel.
-
-    :param kernel: Kernel.
-    :param game: Game in OpenSpiel.
-    :return: Game.
-    """
-    dtype = kernel.data_type
-    scipy = kernel.scipy
-    game = load_game(game)
-    player_count = game.num_players()
-    actions = [defaultdict(OrderedSet) for _ in range(player_count)]
-    parent_sequences = [{} for _ in range(player_count)]
-    raw_payoffs = [defaultdict(int) for _ in range(player_count)]
-
-    def dfs(state, chance_probability, sequences):
-        if state.is_terminal():
-            key = tuple(sequences)
-
-            for i, u in enumerate(state.rewards()):
-                raw_payoffs[i][key] += chance_probability * u
-        elif state.is_chance_node():
-            for a, p in state.chance_outcomes():
-                dfs(state.child(a), p * chance_probability, sequences)
-        else:
-            i = state.current_player()
-            j = state.information_state_string()
-            p_j = sequences[i]
-            parent_sequences[i][j] = p_j
-
-            for a in state.legal_actions():
-                next_state = state.child(a)
-                a = state.action_to_string(a)
-                next_sequences = sequences.copy()
-                next_sequences[i] = j, a
-
-                actions[i][j].add(a)
-                dfs(next_state, chance_probability, next_sequences)
-
-    dfs(game.new_initial_state(), 1, [None] * player_count)
-
-    sequence_form_polytopes = tuple(
-        starmap(
-            partial(SequenceFormPolytope, kernel),
-            zip(actions, parent_sequences),
-        ),
-    )
-    dimensions = tuple(sfp.column_count for sfp in sequence_form_polytopes)
-
-    if (
-            player_count == 2
-            and game.get_type().utility == GameType.Utility.ZERO_SUM
-    ):
-        type_ = TwoPlayerZeroSumExtensiveFormGame
-        payoffs = lil_array(dimensions, dtype=dtype)
-
-        for sequences, payoff in raw_payoffs[0].items():
-            indices = []
-
-            for sfp, sequence in zip(sequence_form_polytopes, sequences):
-                indices.append(sfp.column(sequence))
-
-            payoffs[tuple(indices)] = payoff
-
-        payoffs = scipy.sparse.csr_array(payoffs)
-    else:
-        raise NotImplementedError
-
-    return type_(kernel, payoffs, sequence_form_polytopes)