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)
| 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)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| 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.