noregret 0.0.0.dev5__tar.gz → 0.0.0.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev5
+Version: 0.0.0.dev6
 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 91% 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 95% code coverage.
 
 Features
 --------

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/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 91% 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 95% code coverage.
 
 Features
 --------

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/games/black_box.py

@@ -85,11 +85,11 @@ class BlackBoxGame(ABC):
         """
 
     @abstractmethod
-    def utility(self, player, node):
+    def utility(self, node, player):
         """Return the utility given a player and a node.
 
-        :param player: Player.
         :param node: Node.
+        :param player: Player.
         :return: Utility.
         """
 
@@ -99,9 +99,7 @@ class BlackBoxGame(ABC):
         :param node: Node.
         :return: Utilities.
         """
-        P = range(self.player_count)
-
-        return list(map(self.utility(i, node) for i in P))
+        return list(map(partial(self.utility, node), range(self.player_count)))
 
     @abstractmethod
     def information_set(self, node):
@@ -128,7 +126,7 @@ class BlackBoxGame(ABC):
         """
         A = self.actions(node)
 
-        return list(map(self.chance_probability(node, a) for a in A))
+        return list(map(partial(self.chance_probability, node), A))
 
 
 @dataclass
@@ -168,14 +166,14 @@ class _OpenSpielBlackBoxGame(BlackBoxGame):
             actions.append(node.action_to_string(a))
             children.append(node.child(a))
 
-        return actions, children
+        return OrderedSet(actions), children
 
     def player(self, node):
         i = node.current_player()
 
         return None if i == -1 else i
 
-    def utility(self, player, node):
+    def utility(self, node, player):
         return node.player_reward(player)
 
     def utilities(self, node):

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/games/extensive_form/games.py

@@ -122,12 +122,12 @@ class TwoPlayerExtensiveFormGame(TwoPlayerMultilinearGame, ExtensiveFormGame):
     def row_best_response_value(self, column_strategy):
         u = self.row_utility(column_strategy)
 
-        return self.row_sequence_form_polytopes.best_response_value(u)
+        return self.row_sequence_form_polytope.best_response_value(u)
 
     def column_best_response_value(self, row_strategy):
         v = self.column_utility(row_strategy)
 
-        return self.column_sequence_form_polytopes.best_response_value(v)
+        return self.column_sequence_form_polytope.best_response_value(v)
 
 
 @dataclass

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/games/games.py

@@ -98,12 +98,14 @@ class Game(ABC):
         :param strategy_profile: Strategy profile.
         :return: Nash gap.
         """
-        expected_utilities = self.expected_utilities(strategy_profile)
-        best_response_values = self.best_response_values(strategy_profile)
+        expected_utilities = self.expected_utilities(*strategy_profile)
+        best_response_values = self.best_response_values(*strategy_profile)
+        nash_gap = 0
 
-        assert (best_response_values >= expected_utilities).all()
+        for u, u_prime in zip(best_response_values, expected_utilities):
+            assert u >= u_prime
 
-        nash_gap = (best_response_values - expected_utilities).sum()
+            nash_gap += u - u_prime
 
         return nash_gap
 

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/games/multilinear.py

@@ -122,12 +122,6 @@ class TwoPlayerMultilinearGame(TwoPlayerGame, MultilinearGame, ABC):
     def expected_column_utility(self, row_strategy, column_strategy):
         return row_strategy @ self.column_payoffs @ column_strategy
 
-    def expected_utility(self, player, row_strategy, column_strategy):
-        return row_strategy @ self.payoffs[player] @ column_strategy
-
-    def expected_utilities(self, row_strategy, column_strategy):
-        return row_strategy @ self.payoffs @ column_strategy
-
 
 @dataclass
 class TwoPlayerZeroSumMultilinearGame(
@@ -144,7 +138,7 @@ class TwoPlayerZeroSumMultilinearGame(
     def __post_init__(self):
         super(MultilinearGame, self).__post_init__()
 
-        if self.payoffs.shape != (self.row_dimension, self.column_dimension):
+        if self.payoffs.shape != self.dimensions:
             raise ValueError('inconsistent dimensions')
 
     @property

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/games/normal_form/games.py

@@ -90,10 +90,13 @@ class TwoPlayerNormalFormGame(TwoPlayerMultilinearGame, NormalFormGame):
         """
         return len(self.column_actions)
 
-    def row_best_response_value(self, player, column_strategy):
+    def expected_utilities(self, row_strategy, column_strategy):
+        return row_strategy @ self.payoffs @ column_strategy
+
+    def row_best_response_value(self, column_strategy):
         return self.row_utility(column_strategy).max()
 
-    def column_best_response_value(self, player, row_strategy):
+    def column_best_response_value(self, row_strategy):
         return self.column_utility(row_strategy).max()
 
 

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/games/utilities.py

@@ -1,3 +1,4 @@
+"""Module for utilities."""
 from collections import defaultdict
 from functools import partial, singledispatch
 from itertools import starmap

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/sequence_form_polytopes.py

@@ -303,8 +303,7 @@ class SequenceFormPolytope:
 
         u = utility.copy()
 
-        for L_R, L_A, L_B, L_C_B in zip(
-                self._L_R[::-1],
+        for L_A, L_B, L_C_B in zip(
                 self._L_A[::-1],
                 self._L_B[::-1],
                 self._L_C_B2[::-1],
@@ -328,8 +327,7 @@ class SequenceFormPolytope:
 
         u = utility.copy()
 
-        for L_R, L_A, L_B, L_C_B in zip(
-                self._L_R[::-1],
+        for L_A, L_B, L_C_B in zip(
                 self._L_A[::-1],
                 self._L_B[::-1],
                 self._L_C_B2[::-1],

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret/solvers/regret_minimization.py

@@ -31,6 +31,9 @@ def regret_minimization(
     """
     np = game.kernel.numpy
 
+    if len(regret_minimizers) != game.player_count:
+        raise ValueError('inconsistent number of regret minimizers')
+
     def average_strategy_profile():
         average_strategy_profile = []
 

noregret-0.0.0.dev6/noregret/tests/test_games.py

@@ -0,0 +1,182 @@
+from abc import ABC, abstractmethod
+from unittest import main, TestCase
+
+import noregret as nr
+
+
+class GameTestCaseMixin(ABC):
+    @abstractmethod
+    def uniform_strategy_profile(self, game):
+        pass
+
+    def test_equivalence(self):
+        np = self.KERNEL.numpy
+
+        for game in self.GAMES:
+            x, y = self.uniform_strategy_profile(game)
+
+            self.assertEqual(
+                nr.MultilinearGame.dimensions.fget(game),
+                game.dimensions,
+            )
+            np.testing.assert_allclose(
+                nr.Game.utilities(game, x, y),
+                game.utilities(x, y),
+            )
+            np.testing.assert_allclose(
+                nr.Game.expected_utilities(game, x, y),
+                game.expected_utilities(x, y),
+            )
+            np.testing.assert_allclose(
+                nr.Game.best_response_values(game, x, y),
+                game.best_response_values(x, y),
+            )
+            np.testing.assert_allclose(
+                nr.Game.nash_gap(game, x, y),
+                game.nash_gap(x, y),
+            )
+
+
+class NormalFormGameTestCase(GameTestCaseMixin, TestCase):
+    KERNEL = nr.FloatingPointKernel()
+    GAMES = (
+        nr.AssuranceGame(KERNEL),
+        nr.BattleOfTheSexes(KERNEL),
+        nr.Chicken(KERNEL),
+        nr.GiftExchangeGame(KERNEL),
+        nr.MatchingPennies(KERNEL),
+        nr.PrisonersDilemma(KERNEL),
+        nr.PureCoordination(KERNEL),
+        nr.RockPaperScissors(KERNEL),
+        nr.RockPaperScissorsPlus(KERNEL),
+        nr.RockPaperSuperscissors(KERNEL),
+        nr.StagHunt(KERNEL),
+    )
+
+    def uniform_strategy_profile(self, game):
+        np = self.KERNEL.numpy
+        dtype = self.KERNEL.data_type
+
+        for n in game.dimensions:
+            yield np.full(n, 1 / n, dtype)
+
+    def test_best_response_value(self):
+        np = self.KERNEL.numpy
+
+        for game in self.GAMES:
+            x, y = self.uniform_strategy_profile(game)
+
+            np.testing.assert_allclose(
+                nr.NFG.best_response_value(game, 0, y),
+                game.best_response_value(0, y),
+            )
+            np.testing.assert_allclose(
+                nr.NFG.best_response_value(game, 1, x),
+                game.best_response_value(1, x),
+            )
+
+    def test_serialization(self):
+        for game in self.GAMES:
+            raw_game = game.dumps()
+            game2 = type(game).loads(self.KERNEL, raw_game)
+            raw_game2 = game2.dumps()
+
+            self.assertEqual(raw_game, raw_game2)
+            self.assertTrue((game.payoffs == game2.payoffs).all())
+            self.assertEqual(game.actions, game2.actions)
+
+
+class ExtensiveFormGameTestCase(GameTestCaseMixin, TestCase):
+    KERNEL = nr.FloatingPointKernel()
+    GAMES = (
+        nr.to_efg(nr.MatchingPennies(KERNEL)),
+        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')),
+    )
+
+    def uniform_strategy_profile(self, game):
+        for sfp in game.sequence_form_polytopes:
+            yield sfp.to_sequence_form(sfp.behavioral_form_uniform_strategy)
+
+    def test_best_response_value(self):
+        np = self.KERNEL.numpy
+
+        for game in self.GAMES:
+            x, y = self.uniform_strategy_profile(game)
+
+            np.testing.assert_allclose(
+                nr.EFG.best_response_value(game, 0, y),
+                game.best_response_value(0, y),
+            )
+            np.testing.assert_allclose(
+                nr.EFG.best_response_value(game, 1, x),
+                game.best_response_value(1, x),
+            )
+
+    def test_serialization(self):
+        for game in self.GAMES:
+            raw_game = game.dumps()
+            game2 = type(game).loads(self.KERNEL, raw_game)
+            raw_game2 = game2.dumps()
+
+            self.assertEqual(raw_game, raw_game2)
+            self.assertFalse((game.payoffs != game2.payoffs).count_nonzero())
+
+            for sfp, sfp2 in zip(
+                    game.sequence_form_polytopes,
+                    game2.sequence_form_polytopes,
+            ):
+                self.assertEqual(sfp.actions, sfp2.actions)
+                self.assertEqual(sfp.parent_sequences, sfp2.parent_sequences)
+
+
+class BlackBoxGameTestCase(TestCase):
+    GAMES = nr.from_open_spiel('kuhn_poker'), nr.from_open_spiel('leduc_poker')
+
+    def test_actions_and_children(self):
+        for game in self.GAMES:
+            h = game.root_node
+            A = game.actions(h)
+            children = list(map(str, game.children(h)))
+            A_children = game.actions_and_children(h)
+
+            self.assertIsInstance(A_children, tuple)
+            self.assertEqual(len(A_children), 2)
+
+            A_children = A_children[0], list(map(str, A_children[1]))
+
+            self.assertEqual((A, children), A_children)
+
+            children2 = list(map(str, nr.BlackBoxGame.children(game, h)))
+            A_children2 = nr.BlackBoxGame.actions_and_children(game, h)
+
+            self.assertIsInstance(A_children, tuple)
+            self.assertEqual(len(A_children), 2)
+
+            A_children2 = A_children2[0], list(map(str, A_children2[1]))
+
+            self.assertEqual((A, children2), A_children2)
+            self.assertEqual(A_children, A_children2)
+
+    def test_utilities(self):
+        for game in self.GAMES:
+            h = game.root_node
+            us = game.utilities(h)
+            us2 = nr.BlackBoxGame.utilities(game, h)
+
+            self.assertEqual(us, us2)
+
+    def test_chance_probabilities(self):
+        for game in self.GAMES:
+            h = game.root_node
+            ps = game.chance_probabilities(h)
+            ps2 = nr.BlackBoxGame.chance_probabilities(game, h)
+
+            self.assertEqual(ps, ps2)
+
+
+if __name__ == '__main__':
+    main()  # pragma: no cover

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/noregret.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noregret
-Version: 0.0.0.dev5
+Version: 0.0.0.dev6
 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 91% 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 95% code coverage.
 
 Features
 --------

{noregret-0.0.0.dev5 → noregret-0.0.0.dev6}/setup.py

@@ -4,7 +4,7 @@ from setuptools import find_packages, setup
 
 setup(
     name='noregret',
-    version='0.0.0.dev5',
+    version='0.0.0.dev6',
     description='No-regret learning dynamics',
     long_description=open('README.rst').read(),
     long_description_content_type='text/x-rst',

noregret-0.0.0.dev5/noregret/tests/test_games.py

@@ -1,62 +0,0 @@
-from unittest import main, TestCase
-
-import noregret as nr
-
-
-class NormalFormGameTestCase(TestCase):
-    KERNEL = nr.FloatingPointKernel()
-    GAMES = (
-        nr.AssuranceGame(KERNEL),
-        nr.BattleOfTheSexes(KERNEL),
-        nr.Chicken(KERNEL),
-        nr.GiftExchangeGame(KERNEL),
-        nr.MatchingPennies(KERNEL),
-        nr.PrisonersDilemma(KERNEL),
-        nr.PureCoordination(KERNEL),
-        nr.RockPaperScissors(KERNEL),
-        nr.RockPaperScissorsPlus(KERNEL),
-        nr.RockPaperSuperscissors(KERNEL),
-        nr.StagHunt(KERNEL),
-    )
-
-    def test_serialization(self):
-        for game in self.GAMES:
-            raw_game = game.dumps()
-            game2 = type(game).loads(self.KERNEL, raw_game)
-            raw_game2 = game2.dumps()
-
-            self.assertEqual(raw_game, raw_game2)
-            self.assertTrue((game.payoffs == game2.payoffs).all())
-            self.assertEqual(game.actions, game2.actions)
-
-
-class ExtensiveFormGameTestCase(TestCase):
-    KERNEL = nr.FloatingPointKernel()
-    GAMES = (
-        nr.to_efg(nr.MatchingPennies(KERNEL)),
-        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')),
-    )
-
-    def test_serialization(self):
-        for game in self.GAMES:
-            raw_game = game.dumps()
-            game2 = type(game).loads(self.KERNEL, raw_game)
-            raw_game2 = game2.dumps()
-
-            self.assertEqual(raw_game, raw_game2)
-            self.assertFalse((game.payoffs != game2.payoffs).count_nonzero())
-
-            for sfp, sfp2 in zip(
-                    game.sequence_form_polytopes,
-                    game2.sequence_form_polytopes,
-            ):
-                self.assertEqual(sfp.actions, sfp2.actions)
-                self.assertEqual(sfp.parent_sequences, sfp2.parent_sequences)
-
-
-if __name__ == '__main__':
-    main()  # pragma: no cover