noregret 0.0.0.dev7__tar.gz → 0.0.0.dev8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev7
+Version: 0.0.0.dev8
 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 95% 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 96% code coverage.
 
 Features
 --------
@@ -84,18 +84,18 @@ The code snippet below demonstrates how one can solve games via regret minimizat
 
    from functools import partial
    from math import inf
-   
+
    from tqdm import tqdm
    import matplotlib.pyplot as plt
    import noregret as nr
    import pandas as pd
    import seaborn as sns
-   
-   KERNEL = nr.FloatingPointKernel()
+
+   KER = nr.FPKer()
    GAMES = {
-       'Rock paper superscissors': nr.to_efg(nr.RockPaperSuperscissors(KERNEL)),
-       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
+       'Rock paper superscissors': nr.to_efg(KER, nr.RockPaperSuperscissors(KER)),
+       'Kuhn poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'kuhn_poker')),
+       'Leduc poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'leduc_poker')),
    }
    PARAMETERS = {
        'CFR': (nr.CFR, False, False),
@@ -104,35 +104,35 @@ The code snippet below demonstrates how one can solve games via regret minimizat
        'PCFR+': (partial(nr.CFR_plus, gamma=2), True, True),
        'PCFR+*': (partial(nr.CFR_plus, gamma=inf), True, True),
    }
-   
-   
+
+
    def main():
        for name, game in tqdm(GAMES.items()):
            iterations = []
            exploitabilities = []
            expected_utilities = []
            variants = []
-   
+
            for variant, (R_type, alt, pred) in tqdm(
                    PARAMETERS.items(),
                    leave=False,
            ):
-               R_row = R_type(KERNEL, game.row_sequence_form_polytope)
-               R_col = R_type(KERNEL, game.column_sequence_form_polytope)
-   
+               R_row = R_type(KER, game.row_sequence_form_polytope)
+               R_col = R_type(KER, game.column_sequence_form_polytope)
+
                def update():
                    t = R_row.iteration_count
                    x_bar = R_row.average_strategy
                    y_bar = R_col.average_strategy
                    epsilon = game.exploitability(x_bar, y_bar)
                    u = game.expected_row_utility(x_bar, y_bar)
-   
+
                    iterations.append(t)
                    exploitabilities.append(epsilon)
                    expected_utilities.append(u)
                    variants.append(variant)
-   
-               nr.regret_minimization(
+
+               nr.rm(
                    game,
                    R_row,
                    R_col,
@@ -141,7 +141,7 @@ The code snippet below demonstrates how one can solve games via regret minimizat
                    update=update,
                    progress_bar={'leave': False},
                )
-   
+
            data = {
                'Iteration': iterations,
                'Exploitability': exploitabilities,
@@ -149,21 +149,21 @@ The code snippet below demonstrates how one can solve games via regret minimizat
                'Variant': variants,
            }
            df = pd.DataFrame(data)
-   
+
            plt.clf()
            sns.lineplot(df, x='Iteration', y='Exploitability', hue='Variant')
            plt.xscale('log')
            plt.yscale('log')
            plt.title(f'Exploitability in {name}')
            plt.show()
-   
+
            plt.clf()
            sns.lineplot(df, x='Iteration', y='Expected utility', hue='Variant')
            plt.xscale('log')
            plt.title(f'Expected utility in {name}')
            plt.show()
-   
-   
+
+
    if __name__ == '__main__':
        main()
 
@@ -173,38 +173,34 @@ GPU-Accelerated Game Solving
 The code snippet below demonstrates how one can solve games while leveraging GPU acceleration.
 
 .. code-block:: python
-   
+
    from sys import stdout
-   
+
    from orjson import dumps, OPT_SERIALIZE_NUMPY
    import noregret as nr
-   
-   KERNEL = nr.CUDAKernel()
-   GAME = nr.to_efg(KERNEL, nr.open_spiel_game('liars_dice'))
+
+   CPU_KER = nr.FPKer()
+   GAME = nr.open_spiel_game(CPU_KER, 'liars_dice')
+   GPU_KER = nr.CUDAKer()
+   GAME = nr.to_efg(GPU_KER, GAME)
    PARAMETERS = nr.CFR, True, False
-   
-   
+
+
    def main():
        R_type, alt, pred = PARAMETERS
-       R_row = R_type(KERNEL, GAME.row_sequence_form_polytope)
-       R_col = R_type(KERNEL, GAME.column_sequence_form_polytope)
-       x_bar, y_bar = nr.regret_minimization(
-           GAME,
-           R_row,
-           R_col,
-           alternation=alt,
-           prediction=pred,
-       )
+       R_row = R_type(GPU_KER, GAME.row_sequence_form_polytope)
+       R_col = R_type(GPU_KER, GAME.column_sequence_form_polytope)
+       x_bar, y_bar = nr.rm(GAME, R_row, R_col, alternation=alt, prediction=pred)
        data = {
-           'x_bar': KERNEL.numpy.asnumpy(x_bar),
-           'y_bar': KERNEL.numpy.asnumpy(y_bar),
+           'x_bar': GPU_KER.numpy.asnumpy(x_bar),
+           'y_bar': GPU_KER.numpy.asnumpy(y_bar),
            'Exploitability': GAME.exploitability(x_bar, y_bar).item(),
            'Expected utility': GAME.expected_row_utility(x_bar, y_bar).item(),
        }
-   
+
        stdout.buffer.write(dumps(data, option=OPT_SERIALIZE_NUMPY))
-   
-   
+
+
    if __name__ == '__main__':
        main()
 
@@ -216,23 +212,23 @@ The code snippet below demonstrates how one can solve games via linear programmi
 .. code-block:: python
 
    import noregret as nr
-   
-   KERNEL = nr.FloatingPointKernel()
+
+   KER = nr.FPKer()
    GAMES = {
-       'Rock paper superscissors': nr.RockPaperSuperscissors(KERNEL),
-       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
+       'Rock paper superscissors': nr.RockPaperSuperscissors(KER),
+       'Kuhn poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'kuhn_poker')),
+       'Leduc poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'leduc_poker')),
    }
-   
-   
+
+
    def main():
        for name, game in GAMES.items():
-           x, y = nr.linear_programming(game)
+           x, y = nr.lp(game)
            v = game.expected_row_utility(x, y)
-   
+
            print(f'{name}:', v)
-   
-   
+
+
    if __name__ == '__main__':
        main()
 
@@ -286,11 +282,11 @@ If you use NoRegret in your research, please cite our library:
 .. code-block:: bibtex
 
    @misc{kim2026parallelizingcounterfactualregretminimization,
-         title={Parallelizing Counterfactual Regret Minimization}, 
+         title={Parallelizing Counterfactual Regret Minimization},
          author={Juho Kim and Tuomas Sandholm},
          year={2026},
          eprint={2605.14277},
          archivePrefix={arXiv},
          primaryClass={cs.AI},
-         url={https://arxiv.org/abs/2605.14277}, 
+         url={https://arxiv.org/abs/2605.14277},
    }

{noregret-0.0.0.dev7 → noregret-0.0.0.dev8}/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 95% 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 96% code coverage.
 
 Features
 --------
@@ -34,18 +34,18 @@ The code snippet below demonstrates how one can solve games via regret minimizat
 
    from functools import partial
    from math import inf
-   
+
    from tqdm import tqdm
    import matplotlib.pyplot as plt
    import noregret as nr
    import pandas as pd
    import seaborn as sns
-   
-   KERNEL = nr.FloatingPointKernel()
+
+   KER = nr.FPKer()
    GAMES = {
-       'Rock paper superscissors': nr.to_efg(nr.RockPaperSuperscissors(KERNEL)),
-       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
+       'Rock paper superscissors': nr.to_efg(KER, nr.RockPaperSuperscissors(KER)),
+       'Kuhn poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'kuhn_poker')),
+       'Leduc poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'leduc_poker')),
    }
    PARAMETERS = {
        'CFR': (nr.CFR, False, False),
@@ -54,35 +54,35 @@ The code snippet below demonstrates how one can solve games via regret minimizat
        'PCFR+': (partial(nr.CFR_plus, gamma=2), True, True),
        'PCFR+*': (partial(nr.CFR_plus, gamma=inf), True, True),
    }
-   
-   
+
+
    def main():
        for name, game in tqdm(GAMES.items()):
            iterations = []
            exploitabilities = []
            expected_utilities = []
            variants = []
-   
+
            for variant, (R_type, alt, pred) in tqdm(
                    PARAMETERS.items(),
                    leave=False,
            ):
-               R_row = R_type(KERNEL, game.row_sequence_form_polytope)
-               R_col = R_type(KERNEL, game.column_sequence_form_polytope)
-   
+               R_row = R_type(KER, game.row_sequence_form_polytope)
+               R_col = R_type(KER, game.column_sequence_form_polytope)
+
                def update():
                    t = R_row.iteration_count
                    x_bar = R_row.average_strategy
                    y_bar = R_col.average_strategy
                    epsilon = game.exploitability(x_bar, y_bar)
                    u = game.expected_row_utility(x_bar, y_bar)
-   
+
                    iterations.append(t)
                    exploitabilities.append(epsilon)
                    expected_utilities.append(u)
                    variants.append(variant)
-   
-               nr.regret_minimization(
+
+               nr.rm(
                    game,
                    R_row,
                    R_col,
@@ -91,7 +91,7 @@ The code snippet below demonstrates how one can solve games via regret minimizat
                    update=update,
                    progress_bar={'leave': False},
                )
-   
+
            data = {
                'Iteration': iterations,
                'Exploitability': exploitabilities,
@@ -99,21 +99,21 @@ The code snippet below demonstrates how one can solve games via regret minimizat
                'Variant': variants,
            }
            df = pd.DataFrame(data)
-   
+
            plt.clf()
            sns.lineplot(df, x='Iteration', y='Exploitability', hue='Variant')
            plt.xscale('log')
            plt.yscale('log')
            plt.title(f'Exploitability in {name}')
            plt.show()
-   
+
            plt.clf()
            sns.lineplot(df, x='Iteration', y='Expected utility', hue='Variant')
            plt.xscale('log')
            plt.title(f'Expected utility in {name}')
            plt.show()
-   
-   
+
+
    if __name__ == '__main__':
        main()
 
@@ -123,38 +123,34 @@ GPU-Accelerated Game Solving
 The code snippet below demonstrates how one can solve games while leveraging GPU acceleration.
 
 .. code-block:: python
-   
+
    from sys import stdout
-   
+
    from orjson import dumps, OPT_SERIALIZE_NUMPY
    import noregret as nr
-   
-   KERNEL = nr.CUDAKernel()
-   GAME = nr.to_efg(KERNEL, nr.open_spiel_game('liars_dice'))
+
+   CPU_KER = nr.FPKer()
+   GAME = nr.open_spiel_game(CPU_KER, 'liars_dice')
+   GPU_KER = nr.CUDAKer()
+   GAME = nr.to_efg(GPU_KER, GAME)
    PARAMETERS = nr.CFR, True, False
-   
-   
+
+
    def main():
        R_type, alt, pred = PARAMETERS
-       R_row = R_type(KERNEL, GAME.row_sequence_form_polytope)
-       R_col = R_type(KERNEL, GAME.column_sequence_form_polytope)
-       x_bar, y_bar = nr.regret_minimization(
-           GAME,
-           R_row,
-           R_col,
-           alternation=alt,
-           prediction=pred,
-       )
+       R_row = R_type(GPU_KER, GAME.row_sequence_form_polytope)
+       R_col = R_type(GPU_KER, GAME.column_sequence_form_polytope)
+       x_bar, y_bar = nr.rm(GAME, R_row, R_col, alternation=alt, prediction=pred)
        data = {
-           'x_bar': KERNEL.numpy.asnumpy(x_bar),
-           'y_bar': KERNEL.numpy.asnumpy(y_bar),
+           'x_bar': GPU_KER.numpy.asnumpy(x_bar),
+           'y_bar': GPU_KER.numpy.asnumpy(y_bar),
            'Exploitability': GAME.exploitability(x_bar, y_bar).item(),
            'Expected utility': GAME.expected_row_utility(x_bar, y_bar).item(),
        }
-   
+
        stdout.buffer.write(dumps(data, option=OPT_SERIALIZE_NUMPY))
-   
-   
+
+
    if __name__ == '__main__':
        main()
 
@@ -166,23 +162,23 @@ The code snippet below demonstrates how one can solve games via linear programmi
 .. code-block:: python
 
    import noregret as nr
-   
-   KERNEL = nr.FloatingPointKernel()
+
+   KER = nr.FPKer()
    GAMES = {
-       'Rock paper superscissors': nr.RockPaperSuperscissors(KERNEL),
-       'Kuhn poker': nr.to_efg(KERNEL, nr.open_spiel_game('kuhn_poker')),
-       'Leduc poker': nr.to_efg(KERNEL, nr.open_spiel_game('leduc_poker')),
+       'Rock paper superscissors': nr.RockPaperSuperscissors(KER),
+       'Kuhn poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'kuhn_poker')),
+       'Leduc poker': nr.to_efg(KER, nr.open_spiel_game(KER, 'leduc_poker')),
    }
-   
-   
+
+
    def main():
        for name, game in GAMES.items():
-           x, y = nr.linear_programming(game)
+           x, y = nr.lp(game)
            v = game.expected_row_utility(x, y)
-   
+
            print(f'{name}:', v)
-   
-   
+
+
    if __name__ == '__main__':
        main()
 
@@ -236,11 +232,11 @@ If you use NoRegret in your research, please cite our library:
 .. code-block:: bibtex
 
    @misc{kim2026parallelizingcounterfactualregretminimization,
-         title={Parallelizing Counterfactual Regret Minimization}, 
+         title={Parallelizing Counterfactual Regret Minimization},
          author={Juho Kim and Tuomas Sandholm},
          year={2026},
          eprint={2605.14277},
          archivePrefix={arXiv},
          primaryClass={cs.AI},
-         url={https://arxiv.org/abs/2605.14277}, 
+         url={https://arxiv.org/abs/2605.14277},
    }

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

@@ -72,6 +72,8 @@ CFR2 = CounterfactualRegretMinimization2
 """Alias for :class:`noregret.CounterfactualRegretMinimization2`."""
 CFR_plus = CounterfactualRegretMinimizationPlus
 """Alias for :class:`noregret.CounterfactualRegretMinimizationPlus`."""
+CUDAKer = CUDAKernel
+"""Alias for :class:`CUDAKernel`."""
 DCFR = DiscountedCounterfactualRegretMinimization
 """Alias for
 :class:`noregret.DiscountedCounterfactualRegretMinimization`.
@@ -86,6 +88,8 @@ EFG = ExtensiveFormGame
 """Alias for :class:`noregret.ExtensiveFormGame`."""
 ER = EuclideanRegularization
 """Alias for :class:`noregret.EuclideanRegularization`."""
+FPKer = FloatingPointKernel
+"""Alias for :class:`FloatingPointKernel`."""
 FTRL = FollowTheRegularizedLeader
 """Alias for :class:`noregret.FollowTheRegularizedLeader`."""
 lp = linear_programming
@@ -125,6 +129,7 @@ __all__ = (
     'CounterfactualRegretMinimization',
     'CounterfactualRegretMinimization2',
     'CounterfactualRegretMinimizationPlus',
+    'CUDAKer',
     'CUDAKernel',
     'DCFR',
     'DiscountedCounterfactualRegretMinimization',
@@ -139,7 +144,7 @@ __all__ = (
     'ExtensiveFormGame',
     'FloatingPointKernel',
     'FollowTheRegularizedLeader',
-    'open_spiel_game',
+    'FPKer',
     'FTRL',
     'Game',
     'GiftExchangeGame',
@@ -161,6 +166,7 @@ __all__ = (
     'NormalFormGame',
     'OGD',
     'OnlineGradientDescent',
+    'open_spiel_game',
     'PrisonersDilemma',
     'ProbabilitySimplexRegretMinimizer',
     'ProbabilitySimplexSwapRegretMinimizer',

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

@@ -6,10 +6,14 @@ from functools import partial
 from ordered_set import OrderedSet
 from pyspiel import GameType, load_game
 
+from noregret.kernels import Kernel
+
 
 @dataclass
 class BlackBoxGame(ABC):
     """Abstract base class for black box games."""
+    kernel: Kernel
+    """Kernel."""
 
     @property
     @abstractmethod
@@ -99,7 +103,11 @@ class BlackBoxGame(ABC):
         :param node: Node.
         :return: Utilities.
         """
-        return list(map(partial(self.utility, node), range(self.player_count)))
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
+        us = list(map(partial(self.utility, node), range(self.player_count)))
+
+        return np.array(us, dtype)
 
     @abstractmethod
     def information_set(self, node):
@@ -124,9 +132,12 @@ class BlackBoxGame(ABC):
         :param node: Node.
         :return: Chance probabilities.
         """
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
         A = self.actions(node)
+        ps = list(map(partial(self.chance_probability, node), A))
 
-        return list(map(partial(self.chance_probability, node), A))
+        return np.array(ps, dtype)
 
 
 @dataclass
@@ -174,25 +185,39 @@ class _OpenSpielBlackBoxGame(BlackBoxGame):
         return None if i < 0 else i
 
     def utility(self, node, player):
-        return node.player_reward(player)
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
+
+        return np.array(node.player_reward(player), dtype)
 
     def utilities(self, node):
-        return node.rewards()
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
+
+        return np.array(node.rewards(), dtype)
 
     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]
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
+        p = node.chance_outcomes()[self.actions(node).index(action)][1]
+
+        return np.array(p, dtype)
 
     def chance_probabilities(self, node):
-        return [p for _, p in node.chance_outcomes()]
+        np = self.kernel.numpy
+        dtype = self.kernel.data_type
+
+        return np.array([p for _, p in node.chance_outcomes()], dtype)
 
 
-def open_spiel_game(game):
+def open_spiel_game(kernel, game):
     """Load a game from OpenSpiel.
 
+    :param Kernel: Kernel.
     :param game: Game in OpenSpiel.
     :return: Game.
     """
-    return _OpenSpielBlackBoxGame(game)
+    return _OpenSpielBlackBoxGame(kernel, game)