noregret 0.0.0.dev7__tar.gz → 0.0.0.dev9__tar.gz

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

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

@@ -18,6 +18,7 @@ from noregret.games import (
     RockPaperScissorsPlus,
     RockPaperSuperscissors,
     StagHunt,
+    StrategyProfile,
     to_extensive_form_game,
     TwoPlayerExtensiveFormGame,
     TwoPlayerGame,
@@ -27,6 +28,7 @@ from noregret.games import (
     TwoPlayerZeroSumGame,
     TwoPlayerZeroSumMultilinearGame,
     TwoPlayerZeroSumNormalFormGame,
+    UniformStrategyProfile,
 )
 from noregret.kernels import (
     CUDAKernel,
@@ -46,6 +48,7 @@ from noregret.regret_minimizers import (
     EuclideanRegularization,
     FollowTheRegularizedLeader,
     MirrorDescent,
+    MonteCarloCounterfactualRegretMinimization,
     MultiplicativeWeightsUpdate,
     OnlineGradientDescent,
     ProbabilitySimplexRegretMinimizer,
@@ -54,15 +57,17 @@ from noregret.regret_minimizers import (
     RegretMatchingPlus,
     RegretMinimizer,
     SequenceFormPolytopeRegretMinimizer,
+    StochasticRegretMinimizer,
     SwapRegretMinimizer,
 )
 from noregret.sequence_form_polytopes import SequenceFormPolytope
 from noregret.solvers import (
     linear_programming,
     regret_minimization,
+    stochastic_regret_minimization,
     symmetric_regret_minimization,
 )
-from noregret.utilities import import_object, tuple_or_none
+from noregret.utilities import import_object, sample, tuple_or_none
 
 BM = BlumMansour
 """Alias for :class:`noregret.BlumMansour`."""
@@ -72,6 +77,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,10 +93,16 @@ 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
 """Alias for :func:`noregret.linear_programming`."""
+MCCFR = MonteCarloCounterfactualRegretMinimization
+"""Alias for
+:class:`noregret.MonteCarloCounterfactualRegretMinimization`.
+"""
 MD = MirrorDescent
 """Alias for :class:`noregret.MirrorDescent`."""
 MWU = MultiplicativeWeightsUpdate
@@ -108,6 +121,8 @@ RM = RegretMatching
 """Alias for :class:`noregret.RegretMatching`."""
 rm = regret_minimization
 """Alias for :func:`noregret.regret_minimization`."""
+stochastic_rm = stochastic_regret_minimization
+"""Alias for :func:`noregret.stochastic_regret_minimization`."""
 symmetric_rm = symmetric_regret_minimization
 """Alias for :func:`noregret.symmetric_regret_minimization`."""
 to_efg = to_extensive_form_game
@@ -125,6 +140,7 @@ __all__ = (
     'CounterfactualRegretMinimization',
     'CounterfactualRegretMinimization2',
     'CounterfactualRegretMinimizationPlus',
+    'CUDAKer',
     'CUDAKernel',
     'DCFR',
     'DiscountedCounterfactualRegretMinimization',
@@ -139,7 +155,7 @@ __all__ = (
     'ExtensiveFormGame',
     'FloatingPointKernel',
     'FollowTheRegularizedLeader',
-    'open_spiel_game',
+    'FPKer',
     'FTRL',
     'Game',
     'GiftExchangeGame',
@@ -150,8 +166,10 @@ __all__ = (
     'lp',
     'MatchingPennies',
     'matrix_game',
+    'MCCFR',
     'MD',
     'MirrorDescent',
+    'MonteCarloCounterfactualRegretMinimization',
     'MultilinearGame',
     'MultiplicativeWeightsUpdate',
     'MWU',
@@ -161,6 +179,7 @@ __all__ = (
     'NormalFormGame',
     'OGD',
     'OnlineGradientDescent',
+    'open_spiel_game',
     'PrisonersDilemma',
     'ProbabilitySimplexRegretMinimizer',
     'ProbabilitySimplexSwapRegretMinimizer',
@@ -175,10 +194,15 @@ __all__ = (
     'RockPaperScissors',
     'RockPaperScissorsPlus',
     'RockPaperSuperscissors',
+    'sample',
     'SequenceFormPolytope',
     'SequenceFormPolytopeRegretMinimizer',
     'Serializable',
     'StagHunt',
+    'stochastic_regret_minimization',
+    'StochasticRegretMinimizer',
+    'stochastic_rm',
+    'StrategyProfile',
     'SwapRegretMinimizer',
     'symmetric_regret_minimization',
     'symmetric_rm',
@@ -193,4 +217,5 @@ __all__ = (
     'TwoPlayerZeroSumGame',
     'TwoPlayerZeroSumMultilinearGame',
     'TwoPlayerZeroSumNormalFormGame',
+    'UniformStrategyProfile',
 )

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

@@ -1,5 +1,10 @@
 """Module for games."""
-from noregret.games.black_box import BlackBoxGame, open_spiel_game
+from noregret.games.black_box import (
+    BlackBoxGame,
+    open_spiel_game,
+    StrategyProfile,
+    UniformStrategyProfile,
+)
 from noregret.games.extensive_form import (
     ExtensiveFormGame,
     to_extensive_form_game,
@@ -49,6 +54,7 @@ __all__ = (
     'RockPaperScissorsPlus',
     'RockPaperSuperscissors',
     'StagHunt',
+    'StrategyProfile',
     'to_extensive_form_game',
     'TwoPlayerExtensiveFormGame',
     'TwoPlayerGame',
@@ -58,4 +64,5 @@ __all__ = (
     'TwoPlayerZeroSumGame',
     'TwoPlayerZeroSumMultilinearGame',
     'TwoPlayerZeroSumNormalFormGame',
+    'UniformStrategyProfile',
 )