noregret 0.0.0.dev4__tar.gz → 0.0.0.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev4
+Version: 0.0.0.dev6
 Summary: No-regret learning dynamics
 Home-page: https://github.com/uoftcprg/noregret
 Author: Universal, Open, Free, and Transparent Computer Poker Research Group
@@ -52,7 +52,7 @@ Dynamic: summary
 NoRegret
 ========
 
-NoRegret is an open-source software library for no-regret learning dynamics and computational game solving, developed by the Universal, Open, Free, and Transparent Computer Poker Research Group. NoRegret implements an extensive array of regret minimizers and game solvers, and also supports GPU-acceleration. The library can be used in a variety of use cases, from solving games to conducting research in online convex optimization. NoRegret's reliability has been established through extensive doctests and unit tests, achieving 91% code coverage.
+NoRegret is an open-source software library for no-regret learning dynamics and computational game solving, developed by the Universal, Open, Free, and Transparent Computer Poker Research Group. NoRegret implements an extensive array of regret minimizers and game solvers, and also supports GPU-acceleration. The library can be used in a variety of use cases, from solving games to conducting research in online convex optimization. NoRegret's reliability has been established through extensive doctests and unit tests, achieving 95% code coverage.
 
 Features
 --------
@@ -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.dev6}/README.rst

@@ -2,7 +2,7 @@
 NoRegret
 ========
 
-NoRegret is an open-source software library for no-regret learning dynamics and computational game solving, developed by the Universal, Open, Free, and Transparent Computer Poker Research Group. NoRegret implements an extensive array of regret minimizers and game solvers, and also supports GPU-acceleration. The library can be used in a variety of use cases, from solving games to conducting research in online convex optimization. NoRegret's reliability has been established through extensive doctests and unit tests, achieving 91% code coverage.
+NoRegret is an open-source software library for no-regret learning dynamics and computational game solving, developed by the Universal, Open, Free, and Transparent Computer Poker Research Group. NoRegret implements an extensive array of regret minimizers and game solvers, and also supports GPU-acceleration. The library can be used in a variety of use cases, from solving games to conducting research in online convex optimization. NoRegret's reliability has been established through extensive doctests and unit tests, achieving 95% code coverage.
 
 Features
 --------
@@ -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.dev6}/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.dev6}/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.dev6/noregret/games/black_box.py

@@ -0,0 +1,198 @@
+"""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, node, player):
+        """Return the utility given a player and a node.
+
+        :param node: Node.
+        :param player: Player.
+        :return: Utility.
+        """
+
+    def utilities(self, node):
+        """Return the utilities given a node.
+
+        :param node: Node.
+        :return: Utilities.
+        """
+        return list(map(partial(self.utility, node), range(self.player_count)))
+
+    @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(partial(self.chance_probability, node), 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 OrderedSet(actions), children
+
+    def player(self, node):
+        i = node.current_player()
+
+        return None if i == -1 else i
+
+    def utility(self, node, player):
+        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.dev6}/noregret/games/extensive_form/games.py

@@ -122,12 +122,12 @@ class TwoPlayerExtensiveFormGame(TwoPlayerMultilinearGame, ExtensiveFormGame):
     def row_best_response_value(self, column_strategy):
         u = self.row_utility(column_strategy)
 
-        return self.row_sequence_form_polytopes.best_response_value(u)
+        return self.row_sequence_form_polytope.best_response_value(u)
 
     def column_best_response_value(self, row_strategy):
         v = self.column_utility(row_strategy)
 
-        return self.column_sequence_form_polytopes.best_response_value(v)
+        return self.column_sequence_form_polytope.best_response_value(v)
 
 
 @dataclass

{noregret-0.0.0.dev4 → noregret-0.0.0.dev6}/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.
@@ -97,12 +98,14 @@ class Game(ABC):
         :param strategy_profile: Strategy profile.
         :return: Nash gap.
         """
-        expected_utilities = self.expected_utilities(strategy_profile)
-        best_response_values = self.best_response_values(strategy_profile)
+        expected_utilities = self.expected_utilities(*strategy_profile)
+        best_response_values = self.best_response_values(*strategy_profile)
+        nash_gap = 0
 
-        assert (best_response_values >= expected_utilities).all()
+        for u, u_prime in zip(best_response_values, expected_utilities):
+            assert u >= u_prime
 
-        nash_gap = (best_response_values - expected_utilities).sum()
+            nash_gap += u - u_prime
 
         return nash_gap
 

{noregret-0.0.0.dev4 → noregret-0.0.0.dev6}/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
 
@@ -120,12 +122,6 @@ class TwoPlayerMultilinearGame(TwoPlayerGame, MultilinearGame, ABC):
     def expected_column_utility(self, row_strategy, column_strategy):
         return row_strategy @ self.column_payoffs @ column_strategy
 
-    def expected_utility(self, player, row_strategy, column_strategy):
-        return row_strategy @ self.payoffs[player] @ column_strategy
-
-    def expected_utilities(self, row_strategy, column_strategy):
-        return row_strategy @ self.payoffs @ column_strategy
-
 
 @dataclass
 class TwoPlayerZeroSumMultilinearGame(
@@ -142,7 +138,7 @@ class TwoPlayerZeroSumMultilinearGame(
     def __post_init__(self):
         super(MultilinearGame, self).__post_init__()
 
-        if self.payoffs.shape != (self.row_dimension, self.column_dimension):
+        if self.payoffs.shape != self.dimensions:
             raise ValueError('inconsistent dimensions')
 
     @property

{noregret-0.0.0.dev4 → noregret-0.0.0.dev6}/noregret/games/normal_form/games.py

@@ -90,10 +90,13 @@ class TwoPlayerNormalFormGame(TwoPlayerMultilinearGame, NormalFormGame):
         """
         return len(self.column_actions)
 
-    def row_best_response_value(self, player, column_strategy):
+    def expected_utilities(self, row_strategy, column_strategy):
+        return row_strategy @ self.payoffs @ column_strategy
+
+    def row_best_response_value(self, column_strategy):
         return self.row_utility(column_strategy).max()
 
-    def column_best_response_value(self, player, row_strategy):
+    def column_best_response_value(self, row_strategy):
         return self.column_utility(row_strategy).max()