noregret 0.0.0.dev6__tar.gz → 0.0.0.dev7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev6
+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
@@ -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.dev6 → noregret-0.0.0.dev7}/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.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.dev6 → 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.dev6 → 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.dev6 → noregret-0.0.0.dev7}/noregret/games/black_box.py

@@ -171,7 +171,7 @@ class _OpenSpielBlackBoxGame(BlackBoxGame):
     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, node, player):
         return node.player_reward(player)
@@ -189,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.dev6 → 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.dev6 → 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
@@ -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.dev6 → 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.dev6 → noregret-0.0.0.dev7}/noregret/games/normal_form/games.py

@@ -115,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.dev6 → noregret-0.0.0.dev7}/noregret/solvers/regret_minimization.py

@@ -62,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
 
@@ -138,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.dev6 → noregret-0.0.0.dev7}/noregret/tests/test_games.py

@@ -85,6 +85,16 @@ class NormalFormGameTestCase(GameTestCaseMixin, TestCase):
             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()
@@ -93,8 +103,8 @@ class ExtensiveFormGameTestCase(GameTestCaseMixin, 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')),
     )
 
     def uniform_strategy_profile(self, game):
@@ -134,7 +144,7 @@ class ExtensiveFormGameTestCase(GameTestCaseMixin, TestCase):
 
 
 class BlackBoxGameTestCase(TestCase):
-    GAMES = nr.from_open_spiel('kuhn_poker'), nr.from_open_spiel('leduc_poker')
+    GAMES = nr.open_spiel_game('kuhn_poker'), nr.open_spiel_game('leduc_poker')
 
     def test_actions_and_children(self):
         for game in self.GAMES:

{noregret-0.0.0.dev6 → 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.dev6 → 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.dev6 → noregret-0.0.0.dev7}/noregret.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev6
+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
@@ -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.dev6 → 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.dev6 → noregret-0.0.0.dev7}/setup.py

@@ -4,7 +4,7 @@ from setuptools import find_packages, setup
 
 setup(
     name='noregret',
-    version='0.0.0.dev6',
+    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.dev6/noregret/games/utilities.py

@@ -1,141 +0,0 @@
-"""Module for utilities."""
-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.dev6 → 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,