noregret 0.0.0.dev5__tar.gz → 0.0.0.dev7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev5
+Version: 0.0.0.dev7
 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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('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.to_efg(KERNEL, nr.from_open_spiel('liars_dice'))
+   GAME = nr.to_efg(KERNEL, nr.open_spiel_game('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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
    }
    
    

{noregret-0.0.0.dev5 → noregret-0.0.0.dev7}/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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('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.to_efg(KERNEL, nr.from_open_spiel('liars_dice'))
+   GAME = nr.to_efg(KERNEL, nr.open_spiel_game('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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
    }
    
    

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

@@ -5,19 +5,20 @@ from noregret.games import (
     BlackBoxGame,
     Chicken,
     ExtensiveFormGame,
-    from_open_spiel,
     Game,
     GiftExchangeGame,
     MatchingPennies,
+    matrix_game,
     MultilinearGame,
     NormalFormGame,
+    open_spiel_game,
     PrisonersDilemma,
     PureCoordination,
     RockPaperScissors,
     RockPaperScissorsPlus,
     RockPaperSuperscissors,
     StagHunt,
-    to_extensive_form,
+    to_extensive_form_game,
     TwoPlayerExtensiveFormGame,
     TwoPlayerGame,
     TwoPlayerMultilinearGame,
@@ -109,8 +110,8 @@ rm = regret_minimization
 """Alias for :func:`noregret.regret_minimization`."""
 symmetric_rm = symmetric_regret_minimization
 """Alias for :func:`noregret.symmetric_regret_minimization`."""
-to_efg = to_extensive_form
-"""Alias for :func:`noregret.to_extensive_form`."""
+to_efg = to_extensive_form_game
+"""Alias for :func:`noregret.to_extensive_form_game`."""
 
 __all__ = (
     'AssuranceGame',
@@ -138,7 +139,7 @@ __all__ = (
     'ExtensiveFormGame',
     'FloatingPointKernel',
     'FollowTheRegularizedLeader',
-    'from_open_spiel',
+    'open_spiel_game',
     'FTRL',
     'Game',
     'GiftExchangeGame',
@@ -148,6 +149,7 @@ __all__ = (
     'linear_programming',
     'lp',
     'MatchingPennies',
+    'matrix_game',
     'MD',
     'MirrorDescent',
     'MultilinearGame',
@@ -181,7 +183,7 @@ __all__ = (
     'symmetric_regret_minimization',
     'symmetric_rm',
     'to_efg',
-    'to_extensive_form',
+    'to_extensive_form_game',
     'tuple_or_none',
     'TwoPlayerExtensiveFormGame',
     'TwoPlayerGame',

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

@@ -1,7 +1,8 @@
 """Module for games."""
-from noregret.games.black_box import BlackBoxGame, from_open_spiel
+from noregret.games.black_box import BlackBoxGame, open_spiel_game
 from noregret.games.extensive_form import (
     ExtensiveFormGame,
+    to_extensive_form_game,
     TwoPlayerExtensiveFormGame,
     TwoPlayerZeroSumExtensiveFormGame,
 )
@@ -17,6 +18,7 @@ from noregret.games.normal_form import (
     Chicken,
     GiftExchangeGame,
     MatchingPennies,
+    matrix_game,
     NormalFormGame,
     PrisonersDilemma,
     PureCoordination,
@@ -27,7 +29,6 @@ from noregret.games.normal_form import (
     TwoPlayerNormalFormGame,
     TwoPlayerZeroSumNormalFormGame,
 )
-from noregret.games.utilities import to_extensive_form
 
 __all__ = (
     'AssuranceGame',
@@ -35,19 +36,20 @@ __all__ = (
     'BlackBoxGame',
     'Chicken',
     'ExtensiveFormGame',
-    'from_open_spiel',
     'Game',
     'GiftExchangeGame',
     'MatchingPennies',
+    'matrix_game',
     'MultilinearGame',
     'NormalFormGame',
+    'open_spiel_game',
     'PrisonersDilemma',
     'PureCoordination',
     'RockPaperScissors',
     'RockPaperScissorsPlus',
     'RockPaperSuperscissors',
     'StagHunt',
-    'to_extensive_form',
+    'to_extensive_form_game',
     'TwoPlayerExtensiveFormGame',
     'TwoPlayerGame',
     'TwoPlayerMultilinearGame',

{noregret-0.0.0.dev5 → noregret-0.0.0.dev7}/noregret/games/black_box.py

@@ -85,11 +85,11 @@ class BlackBoxGame(ABC):
         """
 
     @abstractmethod
-    def utility(self, player, node):
+    def utility(self, node, player):
         """Return the utility given a player and a node.
 
-        :param player: Player.
         :param node: Node.
+        :param player: Player.
         :return: Utility.
         """
 
@@ -99,9 +99,7 @@ class BlackBoxGame(ABC):
         :param node: Node.
         :return: Utilities.
         """
-        P = range(self.player_count)
-
-        return list(map(self.utility(i, node) for i in P))
+        return list(map(partial(self.utility, node), range(self.player_count)))
 
     @abstractmethod
     def information_set(self, node):
@@ -128,7 +126,7 @@ class BlackBoxGame(ABC):
         """
         A = self.actions(node)
 
-        return list(map(self.chance_probability(node, a) for a in A))
+        return list(map(partial(self.chance_probability, node), A))
 
 
 @dataclass
@@ -168,14 +166,14 @@ class _OpenSpielBlackBoxGame(BlackBoxGame):
             actions.append(node.action_to_string(a))
             children.append(node.child(a))
 
-        return actions, children
+        return OrderedSet(actions), children
 
     def player(self, node):
         i = node.current_player()
 
-        return None if i == -1 else i
+        return None if i < 0 else i
 
-    def utility(self, player, node):
+    def utility(self, node, player):
         return node.player_reward(player)
 
     def utilities(self, node):
@@ -191,7 +189,7 @@ class _OpenSpielBlackBoxGame(BlackBoxGame):
         return [p for _, p in node.chance_outcomes()]
 
 
-def from_open_spiel(game):
+def open_spiel_game(game):
     """Load a game from OpenSpiel.
 
     :param game: Game in OpenSpiel.

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

@@ -1,12 +1,14 @@
 """Module for extensive-form games (EFGs)."""
 from noregret.games.extensive_form.games import (
     ExtensiveFormGame,
+    to_extensive_form_game,
     TwoPlayerExtensiveFormGame,
     TwoPlayerZeroSumExtensiveFormGame,
 )
 
 __all__ = (
     'ExtensiveFormGame',
+    'to_extensive_form_game',
     'TwoPlayerExtensiveFormGame',
     'TwoPlayerZeroSumExtensiveFormGame',
 )

{noregret-0.0.0.dev5 → noregret-0.0.0.dev7}/noregret/games/extensive_form/games.py

@@ -1,16 +1,26 @@
 """Module for extensive-form games (EFGs)."""
+from collections import defaultdict
 from dataclasses import dataclass
+from functools import partial, singledispatch
 from io import BytesIO
+from itertools import starmap
 
 from ordered_set import OrderedSet
 from orjson import dumps, loads
-from scipy.sparse import load_npz, save_npz
+from scipy.sparse import lil_array, load_npz, save_npz
 
+from noregret.games.black_box import BlackBoxGame
+from noregret.games.games import Game
 from noregret.games.multilinear import (
     MultilinearGame,
     TwoPlayerMultilinearGame,
     TwoPlayerZeroSumMultilinearGame,
 )
+from noregret.games.normal_form.games import (
+    NormalFormGame,
+    TwoPlayerNormalFormGame,
+    TwoPlayerZeroSumNormalFormGame,
+)
 from noregret.kernels import Serializable
 from noregret.sequence_form_polytopes import SequenceFormPolytope
 from noregret.utilities import tuple_or_none
@@ -122,12 +132,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
@@ -143,3 +153,123 @@ class TwoPlayerZeroSumExtensiveFormGame(
         neg_v = self.column_sequence_form_polytope.worst_response_value(neg_v)
 
         return u, neg_v
+
+
+def _nfg2efg(kernel, game, decision_points='p{}'.format):
+    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_game(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_game.register
+def _(game: Game):
+    return to_extensive_form_game(game.kernel, game)

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

@@ -98,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.dev5 → noregret-0.0.0.dev7}/noregret/games/multilinear.py

@@ -122,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(
@@ -144,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.dev5 → noregret-0.0.0.dev7}/noregret/games/normal_form/__init__.py

@@ -5,6 +5,7 @@ from noregret.games.normal_form.games import (
     Chicken,
     GiftExchangeGame,
     MatchingPennies,
+    matrix_game,
     NormalFormGame,
     PrisonersDilemma,
     PureCoordination,
@@ -22,6 +23,7 @@ __all__ = (
     'Chicken',
     'GiftExchangeGame',
     'MatchingPennies',
+    'matrix_game',
     'NormalFormGame',
     'PrisonersDilemma',
     'PureCoordination',

{noregret-0.0.0.dev5 → noregret-0.0.0.dev7}/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()
 
 
@@ -112,6 +115,22 @@ class TwoPlayerZeroSumNormalFormGame(
         return u, neg_v
 
 
+def matrix_game(kernel, matrix):
+    """Create a matrix game.
+
+    :param kernel: Kernel.
+    :param matrix: Matrix.
+    :return: Game.
+    """
+    R, C = matrix.shape
+    actions = (
+        OrderedSet(map('r{}'.format, range(R))),
+        OrderedSet(map('c{}'.format, range(C))),
+    )
+
+    return TwoPlayerZeroSumNormalFormGame(kernel, matrix, actions)
+
+
 def _2p_nfg(name, kernel):
     with open(Path(__file__).parent / f'{name}.json', 'rb') as file:
         return TwoPlayerNormalFormGame.loads(kernel, file.read())

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

@@ -303,8 +303,7 @@ class SequenceFormPolytope:
 
         u = utility.copy()
 
-        for L_R, L_A, L_B, L_C_B in zip(
-                self._L_R[::-1],
+        for L_A, L_B, L_C_B in zip(
                 self._L_A[::-1],
                 self._L_B[::-1],
                 self._L_C_B2[::-1],
@@ -328,8 +327,7 @@ class SequenceFormPolytope:
 
         u = utility.copy()
 
-        for L_R, L_A, L_B, L_C_B in zip(
-                self._L_R[::-1],
+        for L_A, L_B, L_C_B in zip(
                 self._L_A[::-1],
                 self._L_B[::-1],
                 self._L_C_B2[::-1],

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

@@ -31,6 +31,9 @@ def regret_minimization(
     """
     np = game.kernel.numpy
 
+    if len(regret_minimizers) != game.player_count:
+        raise ValueError('inconsistent number of regret minimizers')
+
     def average_strategy_profile():
         average_strategy_profile = []
 
@@ -59,27 +62,32 @@ def regret_minimization(
     for R in regret_minimizers:
         s.append(R.output(prediction))
 
-    for i in iterations:
+    for t in iterations:
         if alternation:
-            for j, R in enumerate(regret_minimizers):
-                R.observe(game.utility(j, *s[:j], *s[j + 1:]))
+            for i, R in enumerate(regret_minimizers):
+                R.observe(game.utility(i, *s[:i], *s[i + 1:]))
 
-                s[j] = R.output(prediction)
+                s[i] = R.output(prediction)
         else:
             U = game.utilities(*s)
 
-            for j, (R, u) in enumerate(zip(regret_minimizers, U)):
+            for i, (R, u) in enumerate(zip(regret_minimizers, U)):
                 R.observe(u)
 
-                s[j] = R.output(prediction)
+                s[i] = R.output(prediction)
 
-        if not checkpoints or i in checkpoints:
+        if not checkpoints or t in checkpoints:
             if update is not None:
-                update()
+                status = update()
+            else:
+                status = False
 
             if (
-                    target_exploitability is not None
-                    and exploitability() < target_exploitability
+                    status
+                    or (
+                        target_exploitability is not None
+                        and exploitability() < target_exploitability
+                    )
             ):
                 break
 
@@ -135,18 +143,23 @@ def symmetric_regret_minimization(
 
     s_neg_1 = [R.output(prediction)] * (game.player_count - 1)
 
-    for i in iterations:
+    for t in iterations:
         R.observe(game.utility(0, *s_neg_1))
 
         s_neg_1 = [R.output(prediction)] * (game.player_count - 1)
 
-        if not checkpoints or i in checkpoints:
+        if not checkpoints or t in checkpoints:
             if update is not None:
-                update()
+                status = update()
+            else:
+                status = False
 
             if (
-                    target_exploitability is not None
-                    and exploitability() < target_exploitability
+                    status
+                    or (
+                        target_exploitability is not None
+                        and exploitability() < target_exploitability
+                    )
             ):
                 break
 

noregret-0.0.0.dev7/noregret/tests/test_games.py

@@ -0,0 +1,192 @@
+from abc import ABC, abstractmethod
+from unittest import main, TestCase
+
+import noregret as nr
+
+
+class GameTestCaseMixin(ABC):
+    @abstractmethod
+    def uniform_strategy_profile(self, game):
+        pass
+
+    def test_equivalence(self):
+        np = self.KERNEL.numpy
+
+        for game in self.GAMES:
+            x, y = self.uniform_strategy_profile(game)
+
+            self.assertEqual(
+                nr.MultilinearGame.dimensions.fget(game),
+                game.dimensions,
+            )
+            np.testing.assert_allclose(
+                nr.Game.utilities(game, x, y),
+                game.utilities(x, y),
+            )
+            np.testing.assert_allclose(
+                nr.Game.expected_utilities(game, x, y),
+                game.expected_utilities(x, y),
+            )
+            np.testing.assert_allclose(
+                nr.Game.best_response_values(game, x, y),
+                game.best_response_values(x, y),
+            )
+            np.testing.assert_allclose(
+                nr.Game.nash_gap(game, x, y),
+                game.nash_gap(x, y),
+            )
+
+
+class NormalFormGameTestCase(GameTestCaseMixin, TestCase):
+    KERNEL = nr.FloatingPointKernel()
+    GAMES = (
+        nr.AssuranceGame(KERNEL),
+        nr.BattleOfTheSexes(KERNEL),
+        nr.Chicken(KERNEL),
+        nr.GiftExchangeGame(KERNEL),
+        nr.MatchingPennies(KERNEL),
+        nr.PrisonersDilemma(KERNEL),
+        nr.PureCoordination(KERNEL),
+        nr.RockPaperScissors(KERNEL),
+        nr.RockPaperScissorsPlus(KERNEL),
+        nr.RockPaperSuperscissors(KERNEL),
+        nr.StagHunt(KERNEL),
+    )
+
+    def uniform_strategy_profile(self, game):
+        np = self.KERNEL.numpy
+        dtype = self.KERNEL.data_type
+
+        for n in game.dimensions:
+            yield np.full(n, 1 / n, dtype)
+
+    def test_best_response_value(self):
+        np = self.KERNEL.numpy
+
+        for game in self.GAMES:
+            x, y = self.uniform_strategy_profile(game)
+
+            np.testing.assert_allclose(
+                nr.NFG.best_response_value(game, 0, y),
+                game.best_response_value(0, y),
+            )
+            np.testing.assert_allclose(
+                nr.NFG.best_response_value(game, 1, x),
+                game.best_response_value(1, x),
+            )
+
+    def test_serialization(self):
+        for game in self.GAMES:
+            raw_game = game.dumps()
+            game2 = type(game).loads(self.KERNEL, raw_game)
+            raw_game2 = game2.dumps()
+
+            self.assertEqual(raw_game, raw_game2)
+            self.assertTrue((game.payoffs == game2.payoffs).all())
+            self.assertEqual(game.actions, game2.actions)
+
+    def test_matrix_game(self):
+        np = self.KERNEL.numpy
+        dtype = self.KERNEL.data_type
+        A = np.array([[3, 0, -3], [0, 3, -4], [0, 0, 1]], dtype)
+        game = nr.matrix_game(self.KERNEL, A)
+        x, y = nr.linear_programming(game)
+        v = game.expected_row_utility(x, y)
+
+        self.assertAlmostEqual(v, 0.25)
+
+
+class ExtensiveFormGameTestCase(GameTestCaseMixin, 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.open_spiel_game('kuhn_poker')),
+        nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
+    )
+
+    def uniform_strategy_profile(self, game):
+        for sfp in game.sequence_form_polytopes:
+            yield sfp.to_sequence_form(sfp.behavioral_form_uniform_strategy)
+
+    def test_best_response_value(self):
+        np = self.KERNEL.numpy
+
+        for game in self.GAMES:
+            x, y = self.uniform_strategy_profile(game)
+
+            np.testing.assert_allclose(
+                nr.EFG.best_response_value(game, 0, y),
+                game.best_response_value(0, y),
+            )
+            np.testing.assert_allclose(
+                nr.EFG.best_response_value(game, 1, x),
+                game.best_response_value(1, x),
+            )
+
+    def test_serialization(self):
+        for game in self.GAMES:
+            raw_game = game.dumps()
+            game2 = type(game).loads(self.KERNEL, raw_game)
+            raw_game2 = game2.dumps()
+
+            self.assertEqual(raw_game, raw_game2)
+            self.assertFalse((game.payoffs != game2.payoffs).count_nonzero())
+
+            for sfp, sfp2 in zip(
+                    game.sequence_form_polytopes,
+                    game2.sequence_form_polytopes,
+            ):
+                self.assertEqual(sfp.actions, sfp2.actions)
+                self.assertEqual(sfp.parent_sequences, sfp2.parent_sequences)
+
+
+class BlackBoxGameTestCase(TestCase):
+    GAMES = nr.open_spiel_game('kuhn_poker'), nr.open_spiel_game('leduc_poker')
+
+    def test_actions_and_children(self):
+        for game in self.GAMES:
+            h = game.root_node
+            A = game.actions(h)
+            children = list(map(str, game.children(h)))
+            A_children = game.actions_and_children(h)
+
+            self.assertIsInstance(A_children, tuple)
+            self.assertEqual(len(A_children), 2)
+
+            A_children = A_children[0], list(map(str, A_children[1]))
+
+            self.assertEqual((A, children), A_children)
+
+            children2 = list(map(str, nr.BlackBoxGame.children(game, h)))
+            A_children2 = nr.BlackBoxGame.actions_and_children(game, h)
+
+            self.assertIsInstance(A_children, tuple)
+            self.assertEqual(len(A_children), 2)
+
+            A_children2 = A_children2[0], list(map(str, A_children2[1]))
+
+            self.assertEqual((A, children2), A_children2)
+            self.assertEqual(A_children, A_children2)
+
+    def test_utilities(self):
+        for game in self.GAMES:
+            h = game.root_node
+            us = game.utilities(h)
+            us2 = nr.BlackBoxGame.utilities(game, h)
+
+            self.assertEqual(us, us2)
+
+    def test_chance_probabilities(self):
+        for game in self.GAMES:
+            h = game.root_node
+            ps = game.chance_probabilities(h)
+            ps2 = nr.BlackBoxGame.chance_probabilities(game, h)
+
+            self.assertEqual(ps, ps2)
+
+
+if __name__ == '__main__':
+    main()  # pragma: no cover

{noregret-0.0.0.dev5 → noregret-0.0.0.dev7}/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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')), -1 / 18),
-        (nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')), -0.08560642408),
+        (nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')), -1 / 18),
+        (nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')), -0.08560642408),
     )
 
     def test_linear_programming(self):

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

@@ -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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')), -1 / 18),
-        (nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')), -0.08560642408),
+        (nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')), -1 / 18),
+        (nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')), -0.08560642408),
     )
     REGRET_MINIMIZION_PARAMETERS = (
         (partial(nr.CFR, KERNEL), False, False),
@@ -157,10 +157,10 @@ class SequenceFormPolytopeRegretMinimization2TestCase(TestCase):
         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')),
+        nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
+        nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
     )
-    PLACES = 6
+    PLACES = 2
 
     def test_equivalence(self):
         for game in self.GAMES:
@@ -186,6 +186,28 @@ class SequenceFormPolytopeRegretMinimization2TestCase(TestCase):
             self.assertAlmostEqual(e, e2, self.PLACES)
             self.assertAlmostEqual(v, v2, self.PLACES)
 
+            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),
+                prediction=True,
+                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),
+                prediction=True,
+                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.dev5 → noregret-0.0.0.dev7}/noregret.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev5
+Version: 0.0.0.dev7
 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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('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.to_efg(KERNEL, nr.from_open_spiel('liars_dice'))
+   GAME = nr.to_efg(KERNEL, nr.open_spiel_game('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.to_efg(KERNEL, nr.from_open_spiel('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.from_open_spiel('leduc_poker')),
+       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
+       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
    }
    
    

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

@@ -14,7 +14,6 @@ noregret/games/__init__.py
 noregret/games/black_box.py
 noregret/games/games.py
 noregret/games/multilinear.py
-noregret/games/utilities.py
 noregret/games/extensive_form/__init__.py
 noregret/games/extensive_form/games.py
 noregret/games/normal_form/__init__.py

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

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

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

@@ -1,140 +0,0 @@
-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.dev5/noregret/tests/test_games.py

@@ -1,62 +0,0 @@
-from unittest import main, TestCase
-
-import noregret as nr
-
-
-class NormalFormGameTestCase(TestCase):
-    KERNEL = nr.FloatingPointKernel()
-    GAMES = (
-        nr.AssuranceGame(KERNEL),
-        nr.BattleOfTheSexes(KERNEL),
-        nr.Chicken(KERNEL),
-        nr.GiftExchangeGame(KERNEL),
-        nr.MatchingPennies(KERNEL),
-        nr.PrisonersDilemma(KERNEL),
-        nr.PureCoordination(KERNEL),
-        nr.RockPaperScissors(KERNEL),
-        nr.RockPaperScissorsPlus(KERNEL),
-        nr.RockPaperSuperscissors(KERNEL),
-        nr.StagHunt(KERNEL),
-    )
-
-    def test_serialization(self):
-        for game in self.GAMES:
-            raw_game = game.dumps()
-            game2 = type(game).loads(self.KERNEL, raw_game)
-            raw_game2 = game2.dumps()
-
-            self.assertEqual(raw_game, raw_game2)
-            self.assertTrue((game.payoffs == game2.payoffs).all())
-            self.assertEqual(game.actions, game2.actions)
-
-
-class ExtensiveFormGameTestCase(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')),
-    )
-
-    def test_serialization(self):
-        for game in self.GAMES:
-            raw_game = game.dumps()
-            game2 = type(game).loads(self.KERNEL, raw_game)
-            raw_game2 = game2.dumps()
-
-            self.assertEqual(raw_game, raw_game2)
-            self.assertFalse((game.payoffs != game2.payoffs).count_nonzero())
-
-            for sfp, sfp2 in zip(
-                    game.sequence_form_polytopes,
-                    game2.sequence_form_polytopes,
-            ):
-                self.assertEqual(sfp.actions, sfp2.actions)
-                self.assertEqual(sfp.parent_sequences, sfp2.parent_sequences)
-
-
-if __name__ == '__main__':
-    main()  # pragma: no cover

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

@@ -1,8 +1,4 @@
 """Module for regret minimizers."""
-from noregret.regret_minimizers.regret_minimizers import (
-    RegretMinimizer,
-    SwapRegretMinimizer,
-)
 from noregret.regret_minimizers.probability_simplices import (
     BlumMansour,
     DiscountedRegretMatching,
@@ -17,6 +13,10 @@ from noregret.regret_minimizers.probability_simplices import (
     RegretMatching,
     RegretMatchingPlus,
 )
+from noregret.regret_minimizers.regret_minimizers import (
+    RegretMinimizer,
+    SwapRegretMinimizer,
+)
 from noregret.regret_minimizers.sequence_form_polytopes import (
     CounterfactualRegretMinimization,
     CounterfactualRegretMinimization2,