Skip to main content
Pre-release

This release is a pre-release and may not be stable for production use.

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 96% code coverage.

Features

  • Extensive array of regret minimizers and game solvers.

  • High-speed implementations.

  • Multithreading support (MKL).

  • GPU support (CUDA).

Installation

The NoRegret library requires Python Version 3.12 or above and can be installed using pip:

pip install noregret

Usages

Example usages of NoRegret is shown below.

Solving Games via Regret minimization

The code snippet below demonstrates how one can solve games via regret minimization using NoRegret.

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

KER = nr.FPKer()
GAMES = {
    'Rock paper superscissors': nr.to_efg(KER, nr.RockPaperSuperscissors(KER)),
    'Kuhn poker': nr.to_efg(KER, nr.OpenSpielGame(KER, 'kuhn_poker')),
    'Leduc poker': nr.to_efg(KER, nr.OpenSpielGame(KER, 'leduc_poker')),
}
PARAMETERS = {
    'CFR': (nr.CFR, False, False),
    'CFR+': (nr.CFR_plus, True, False),
    'DCFR': (nr.DCFR, True, False),
    '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(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.rm(
                game,
                R_row,
                R_col,
                alternation=alt,
                prediction=pred,
                update=update,
                progress_bar={'leave': False},
            )

        data = {
            'Iteration': iterations,
            'Exploitability': exploitabilities,
            'Expected utility': expected_utilities,
            '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()

GPU-Accelerated Game Solving

The code snippet below demonstrates how one can solve games while leveraging GPU acceleration.

from sys import stdout

from orjson import dumps, OPT_SERIALIZE_NUMPY
import noregret as nr

CPU_KER = nr.FPKer()
GAME = nr.OpenSpielGame(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(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': 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()

Solving Games via Linear Programming

The code snippet below demonstrates how one can solve games via linear programming using NoRegret.

import noregret as nr

KER = nr.FPKer()
GAMES = {
    'Rock paper superscissors': nr.RockPaperSuperscissors(KER),
    'Kuhn poker': nr.to_efg(KER, nr.OpenSpielGame(KER, 'kuhn_poker')),
    'Leduc poker': nr.to_efg(KER, nr.OpenSpielGame(KER, 'leduc_poker')),
}


def main():
    for name, game in GAMES.items():
        x, y = nr.lp(game)
        v = game.expected_row_utility(x, y)

        print(f'{name}:', v)


if __name__ == '__main__':
    main()

Testing and Validation

Run style checks.

flake8 examples noregret

Run doctests.

shopt -s globstar
python -m doctest noregret/**/*.py

Run unit tests.

python -m unittest

Check coverage.

shopt -s globstar
coverage run -m doctest noregret/**/*.py
coverage run -a -m unittest
coverage report -m
coverage html

Contributing

Contributions are welcome! Please read our Contributing Guide for more information.

License

NoRegret is distributed under the MIT license.

Citing

If you use NoRegret in your research, please cite our library:

@misc{kim2026parallelizingcounterfactualregretminimization,
      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},
}

Metadata

Release files for noregret 0.0.0.dev17

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for noregret 0.0.0.dev17
File Size Uploaded Provenance Actions
noregret-0.0.0.dev17.tar.gz 33.3 kB Without provenance Details for noregret-0.0.0.dev17.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for noregret 0.0.0.dev17
File Interpreter ABI Platform Actions
noregret-0.0.0.dev17-py3-none-any.whl Python 3 none any Details for noregret-0.0.0.dev17-py3-none-any.whl

Total release size: 76.8 kB

Release files / noregret-0.0.0.dev17.tar.gz

Download URL noregret-0.0.0.dev17.tar.gz
Size 33.3 kB
Tags Source
SHA-256 checksum
How to use checksums
aaeaac0fd4681e9b5a37315413223a81c0b3a4d861a1a06322b93da91722bfa9
BLAKE2b-256 checksum
How to use checksums
3b9cb05acaafaad2d3fabe415984ea177802383ba3f63d4c3b7418e4260a39fd
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.2.0 CPython/3.12.3

Release files / noregret-0.0.0.dev17-py3-none-any.whl

Download URL noregret-0.0.0.dev17-py3-none-any.whl
Size 43.5 kB
Tags Python 3
SHA-256 checksum
How to use checksums
fff34553999f8404b0569fa064844834a327898216330508422e188487cbe800
BLAKE2b-256 checksum
How to use checksums
0f13a6c0d4988b61deb4cf746b2576ddb532b87f69dd0a6811e274d2e3038c05
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.2.0 CPython/3.12.3

Security for noregret 0.0.0.dev17

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page