From Poincaré Recurrence to Convergence in Imperfect Information Games: Finding Equilibrium via Regularization
Julien Perolat, Remi Munos, Jean-Baptiste Lespiau, Shayegan Omidshafiei, Mark Rowland, Pedro Ortega, Neil Burch, Thomas Anthony, David Balduzzi, Bart De Vylder, Georgios Piliouras, Marc Lanctot, Karl Tuyls
Introduction
This paper addresses the problem of learning a Nash equilibrium in several classes of games. Learning Nash equilibria in competitive games is complex as agents no longer share information but behave independently. Various techniques have been proposed to solve these games, with the current state-of-the-art usually guaranteeing average-time convergence of the learned policy to a Nash equilibrium, but not necessarily convergence of the policy itself to Nash. Unfortunately, these convergence guarantees are not conducive to learning in large games, which rely on general function approximation techniques (e.g., deep neural networks) that are inherently difficult to time-average. Moreover, the real-time behaviors of the policy can be quite distinctive from its time-average counterpart, and can even diverge away from Nash equilibria (Bailey & Piliouras, 2018).
In some adversarial games, Follow the Regularized Leader (FoReL) is known to be convergent if the equilibrium is deterministic, and recurrent if the equilibrium is mixed with full support (Mertikopoulos et al., 2018). A special case of FoReL dynamics is replicator dynamics (Taylor & Jonker, 1978), the main dynamic of evolutionary game theory, whose recurrent behavior in zero-sum games and generalizations is well studied (Piliouras & Shamma, 2014; Boone & Piliouras, 2019). More generally, value-based methods have been well-studied in multi-agent reinforcement learning (Littman, 1994, 2001; Hu & Wellman, 2003) but numerous issues of convergence have been noticed. But a notable empirical finding shows that regularization of -learning in matrix games can induce the policy to converge in real-time to a Nash equilibrium (Tuyls et al., 2003; Kaisers & Tuyls, 2010, 2011) or in the replicator dynamics to Quantal-Response-Equilibrium (Ortega & Legg, 2018; McKelvey & Palfrey, 1995; Tuyls & Nowé, 2005). Other theoretical investigations show that softmax best response can guarantee convergence in -learning (Leslie & Collins, 2005).
Motivated by these findings, this paper formally analyzes the impact of regularization on learning dynamics, extending beyond the simple case of matrix games and focusing particularly on the application of FoReL to imperfect information games. The contributions of the paper are as follows:
We generalize the Poincaré recurrence result (Mertikopoulos et al., 2018) to the case of sequential imperfect information games. This proves that strategies can cycle in IIG when using FoReL (e.g., similar to the normal form game case Fig. 1, (a)).
We prove that changing the reward structure of the game improves convergence guarantees at the cost of slightly modifying the equilibrium of the game (e.g., as in Fig. 1, (b), (c), (d)).
We show that this reward adaptation method can be used to build a sequence of closer and closer pseudo-solutions converging onto a Nash equilibrium.
We illustrate that by using these theoretical findings, we improve the state-of-the-art of deep reinforcement learning in imperfect information games.
We discuss related work along three axes: (i) follow the regularized leader and regret minimization, (ii) gradient based methods in differentiable games, and (iii) dynamic programming and reinforcement learning approaches in games.
There exists a large corpus of literature providing evidence that minimax equilibria (or Nash equilibria) in normal form zero-sum two-player games are often unstable rest points of FoReL (or at best neutrally stable). In evolutionary game theory, the replicator dynamics (Zeeman, 1980, 1981; Weibull, 1997; Gintis, 2009) are known to be unstable in the case of an interior equilibrium in zero-sum two-player normal form games (Bloembergen et al., 2015). Many machine learning approaches can be used in self-play to learn an equilibrium: regret minimization methods have been extensively studied in zero-sum games (Cesa-Biachi & Lugosi, 2006; Syrgkanis et al., 2015; Fudenberg & Levine, 1998; Zinkevich et al., 2008; Hofbauer et al., 2009; Cesa-Biachi & Lugosi, 2006), for which the average policy played over time converges to an equilibrium, but the actual policy is known to be recurrent (Piliouras & Shamma, 2014; Mertikopoulos et al., 2018). The convergence of the actual policy can be obtained when the opponent plays a best response (Waugh & Bagnell, 2015; Abernethy et al., 2018) but not in the self-play setting. The best response sequences of Fictitious Play (Brown, 1951) and smoother variants (Hofbauer & Sandholm, 2002) converge in time-average. Polymatrix games can be solved by linear programming (Cai et al., 2016) (we will study a generalization of this class). Regret minimization techniques can be used to learn a Nash equilibrium, Since for a coarse correlated equilibrium, the marginals with respect to the players are a Nash equilibrium (Cai et al., 2016) but also in this setting, the convergence to a Nash equilibrium requires to compute a time-average policy, and the policy itself is recurrent (Mertikopoulos et al., 2018).
Differentiable games (e.g. GANs) trained by gradient descent present many failure modes (Balduzzi et al., 2018). In (Balduzzi et al., 2018) the authors prove that learning dynamics of gradient descent can cycle in some classes of games. This problem can be resolved by introducing second-order optimization (Balduzzi et al., 2018; Foerster et al., 2017; Mescheder et al., 2017; Letcher et al., 2019), negative momentum (Gidel et al., 2019) or game theoretic algorithms (Oliehoek et al., 2017; Grnarova et al., 2018).
In sequential imperfect information games RL methods have been applied with mild success. Independent reinforcement learning has many failure modes under these sequential imperfect information settings, as demonstrated in (Lanctot et al., 2017). In zero-sum sequential imperfect information games, the policy can cycle around the minimax equilibrium without ever converging, even in simple single-state games (Piliouras & Shamma, 2014; Mertikopoulos et al., 2018; Singh et al., 2000; Bloembergen et al., 2015; Bailey & Piliouras, 2018). In cooperative settings, players tend to overfit to the opponent while learning, without being able to generalize to other opponents’ behaviors (Matignon et al., 2012). Generally speaking, in the sequential setting, learning in games can be addressed by either approximate dynamic programming in the perfect information case (Lagoudakis & Parr, 2002; Pérolat et al., 2015, 2016, 2016, 2017; Geist et al., 2019), regret minimization algorithms (Zinkevich et al., 2008; Lanctot, 2013; Lanctot et al., 2009) (which suffer from the aforementioned time-averaging problem), best response algorithms (Heinrich et al., 2015; Lanctot et al., 2017; Heinrich & Silver, 2016), model free reinforcement learning methods (Srinivasan et al., 2018; Heinrich & Silver, 2016) or policy gradient in the worst case (Lockhart et al., 2019). However, the previous model free RL methods are not flawless: Neural Fictitious Self Play (NFSP) (Heinrich & Silver, 2016) maintains two data sets of respectively and times the size of the game, the methods presented in (Srinivasan et al., 2018) empirically show a convergence in time-average without formal proof, and (Lockhart et al., 2019) require the exact computation of a best response.
Warming up: Normal Form Games
We first sketch our main results in repeated zero-sum two-player normal form games.
By definition, a policy is a Nash equilibrium if for all and for all we have . In other words, a Nash equilibrium is a joint policy such that no player has an incentive to change its policy if all the other players stick to their policy.
FoReL is an exploration-exploitation algorithm that maximizes the cumulative payoff of the player (exploitation) minus a regularization term (exploration). The continuous time version of this algorithm is defined as follows:
We will write and we have the property that (maximizing argument Shalev-Shwartz et al. (2012, p.147)).
If is a Nash equilibrium, a useful measure of interest that measures the distance to a Nash equilibrium is
This quantity (and its generalization introduced in section. 3) will be used to construct strong Lyapunov functions in many games of interest. As a warm up, this section will explore these convergence results in the normal form case.
If the reward is policy-independent and if there exists an interior equilibrium, it is known that the policy under FoReL will be recurrent (Mertikopoulos et al., 2018). We will generalize this result to sequential Imperfect Information Games in section 4. Crucially, this strong negative result indicates that convergence cannot be achieved with FoReL in games with a mixed strategy equilibrium, so long as the reward is policy-independent. Thus, in the rest of the paper, we will explore how to transform the reward by adding a policy-dependent term to guarantee convergence (see section 5,6).
Section 5 explores the idea of reward transformation by adding a policy dependent term. If the reward is not policy-independent, one can show that:
We later generalize this result in lemma 3.1. As an example, consider the following policy dependent reward, which also preserves the zero-sum property for any policy with a full support:
Given the above reward, we can show that:
This inequality ensures that will converge to , the Nash of the game defined by , using Lyapunov arguments. Note that will depend on and . Transforming the reward improves the convergence property of the game but will shift the equilibrium, a phenomena illustrated in figure 1 where is the entropy for all players. Thus, this technique does not directly guarantee convergence to the Nash of the original game. We next introduce a technique to adapt the policy-dependent term in the reward, thereby guaranteeing convergence to the actual Nash equilibrium of the game.
Solving the original game can be achieved by iteratively solving the game with the reward and use the Nash of that game to modify the reward of the next game (starting with as the uniform policy). The sequence of policies converges to , the equilibrium of the policy-independent reward . Specifically, we can show that:
which is enough to prove that converges to , using Lyapunov-style arguments (this result is proved in section 6). This set of results establishes a foundation for convergent learning in the normal-form case. We next lay out the principles necessary for generalizing to the IIG setting, with our main result detailed in section 6.
Background in Sequential Imperfect Information Games
In a sequential imperfect information game, players and a chance player (written ) interact sequentially starting from a history . The set of all possible histories is written . The sets are the set of histories at player’s turn (all are disjoint). The set of terminal histories is a subset of in which the game has ended (). In each history , the current player will observe an information state . The function provides the player’s turn at a given history. We will also write for the information state corresponding to an history . We will write if .
At each history , the current player will play an action . As a result, each player will receive a reward and the state will transition to . We will write if there exists a sequence of actions such that . The history is then said to be a prefix of .
A policy maps an information state to a distribution over actions . The restriction of over is written and is the restriction of over . We will write . As in section. 2, we consider a policy dependent reward (written ), which can be dependent on the full policy. The rest of this section introduces reinforcement learning tools used to define FoReL in IIG and used in the proofs.
The value of a policy for player at history is defined as follow:
The value of a policy for player at history while taking action is defined as follow:
The reach probability of a history is (note that this product may include the chance player):
The reach probability of player of a history is:
The reach probability of player of a history is (this product may include the chance player too):
In the end, :
The reach probability of an information state is defined as follows:
Under perfect recall (M. Zinkevich, 2007), we can write for any :
And under perfect recall we will write for all Furthermore,
The only information available to a player is the information state. We define the expected value of the game given such an information state as follows:
And the expected -function given and is:
Now we can define a Nash equilibrium in the sequential imperfect information game setting. Formally:
A strategy is a Nash equilibrium if for all and for all :
1 Monotone Games
Let us define . A game is monotone if for all policies , , :
This condition is slightly difficult to interpret but as mentioned above, it captures a wide class of games (zero-sum two-player, polymatrix zero-sum games etc.). See proof in appendix I.
2 Follow the Regularized Leader
Follow the Regularized Leader in imperfect information games defines a sequence of policies for all and as follow:
We define the following quantity for any Nash equilibrium of the game:
This quantity will be at the center of our analysis of Follow the Regularized Leader in sections 4 and 5. The following lemma shows how this quantity evolves if both players learn using Follow the Regularized Leader updates. We will use this quantity to create a Lyapunov function for policy-dependent reward and use it to bound the trajectories of FoReL to prove Poincaré recurrence; intuitively, that “most” trajectories do not converge to equilibria.
If is defined as the follow the regularized leader dynamics we have:
Recurrence of FoReL
This section generalizes the results of (Mertikopoulos et al., 2018) to Follow the Regularized Leader in monotone Imperfect Information Games when the reward is policy-independent (all the zero-sum two-player games implemented in OpenSpiel (Lanctot et al., 2019) have this property) and when the equilibrium has a full support. This requires two steps, first we will prove that an equivalent learning dynamic is Divergence-free (or preserves volume). Then we will use lemma 3.1 to show that all trajectories of this new dynamical system are bounded. This is enough to prove that the trajectories of FoReL are Poincaré recurrent. Intuitively this means that all trajectories will go back to a neighborhood of their starting point arbitrarily often. The Poincaré recurrence theorem (Piliouras & Shamma, 2014; Mertikopoulos et al., 2018; Poincaré, 1890) states:
If a flow preserves volume (is Divergence-free) and has only bounded orbits then for each open set there exist orbits that intersect the set infinitely often.
Instead of studying the original dynamical system, we will fix an action for all and consider the dynamical system (as this system keeps bounded):
In order to get qualitative results on FoReL, we will prove that the FoReL dynamic is Divergence-free (a generalization of a result from Mertikopoulos et al. (2018)).
The system defined above (equation (1) and (2)) is autonomous (can be written as ), Divergence-free, and the dynamic of the policy is equivalent to the one defined in section 3.2 when the reward is policy-independent. (Proof in appendix B)
This property is critical as it implies that the dynamical system has no attractor (Weibull, 1997, p.252, prop 6.6).
This does not mean that the policy will not converge. If the diverges, the policy might converge to a deterministic strategy. However, if the Nash is of full support, it will not be an attractor of the dynamical system.
We now know that Nash equilibria cannot be attractors of FoReL as the system is Divergence-free. In order to prove the Poincaré recurrence, we need to prove an additional property. We need the trajectory to remain bounded if the equilibrium is interior.
If the equilibrium is interior, then .
In a monotone game with a policy-independent reward and an interior equilibrium, if is defined as following the FoReL algorithm we have:
Corolary 4.1 implies that the trajectories of the dynamics equation (1) and (2) are bounded. This can be proven by directly using arguments from (Mertikopoulos et al., 2018, Lemma D.2.).
As we have seen in the two previous paragraphs, the flow of FoReL is Divergence-free and all trajectories are bounded in the case of monotone games with an interior Nash equilibrium. Thus all orbits are Poincaré recurrent.
Reward Transformation and Convergence in IIG
In section 4 we have seen that a policy-independent reward signal can lead to recurrent behavior. The idea we study here is to slightly modify the reward signal such that the Nash equilibrium of this new game is an attractor. We will show two reward transformations that guarantee convergence to a Nash equilibrium (with Lyapunov arguments). The first reward transformation applies generally to monotone games and the second one applies specifically to zero-sum games. But first we briefly recall the Lyapunov method.
The idea of the Lyapunov method to study the ordinary differential equation is to look at the variations of a quantity (and ). The function is said to be a strict Lyapunov function if:
In that case, the will converge to a minimum of if is locally Lipschitz and if is a continuously differentiable function. The function is said to be a strong Lyapunov function if:
In this case, the will converge to a minimum of at an exponentially fast rate .
In the general case of monotone games, the reward that for any preserves the monotonicity is: (see proof in section F)
In monotone games, the reward transformation considered above implies that will be decreasing:
Finally, if the regularizer is the entropy, we can show that the is a strong Lyapunov function:
If the regularizer is the entropy:
it implies: (proof in appendix C)
This method thus introduces a trade-off between the speed of convergence of the algorithm and the transformation we make to the reward (which has an impact on the equilibrium of the transformed game).
Whilst the above approach can be applied to all monotone games, the following reward can be applied specifically to zero-sum games. For any , this reward keeps the zero-sum property (see appendix F) and is more prone to sample based methods as the is not involved,
And here, if the regularizer is the entropy, we can show that the is a strict Lyapunov function:
If the regularizer is the entropy:
with
This imply that:
The proof follows by combining corollary 5.2 and the result in appendix C. ∎
In summary, we saw in this section that exponential convergence rates can be achieved in continuous time in imperfect information games using reward transformation.
Corrolary 5.1 and 5.2 are valid for all Nash of the transformed game. This means that for all , the Nash eq. of the transformed game is unique. This uniqueness property is necessary to define the process of the next section.
Convergence to an Exact Equilibrium
The previous section introduced a reward transformation (by adding a policy dependent term ) to ensure exponential convergence in games. However this method does not ensure convergence to the equilibrium of the game defined on . In this section, we study the sequence of policies starting from , being the uniform policy, and the solution of the game with the reward transformation . Intuitively, this approach entails that the policy will be searched close to the previous iterate (we write ).
Then for any Nash equilibrium of the game , we have the following identity for the sequence of policy :
Where:
And where if the game is monotone (proof in appendix D).
In a monotone game with all Nash equilibrium being interior, the sequence of policy (or ) converges to a Nash equilibrium of the game (proof in appendix H).
We were only able to prove this result for interior Nash but we conjecture that it is still true for non interior Nash equilibrium.
Empirical evaluation
It has already been empirically noted that regularization helps convergence in games (Omidshafiei et al., 2019). Earlier work (Srinivasan et al., 2018) also provides experiments where the current policy converges in Leduc Poker, whilst the paper only proves convergence analysis of the average policy. Our work sheds a new light on those results as the convergence may have been the result of high regularization (the entropy cost added in (Srinivasan et al., 2018) appendix G was ). The experiments will show how reward transform can be used to improve the state of the art of reinforcement Learning in Imperfect Information Games. To keep our implementation as close as possible to FoReL, we use the NeuRD policy update (Omidshafiei et al., 2019), a retrace update to estimate the -function. In order to keep our estimate of the return unbiased, we use that learned -function as a control variate as in (Schmid et al., 2019). The details of the algorithm are in appendix J. We present results on four games: Kuhn Leduc Poker, Goofspiel and Liars Dice, which have respectively 12, 936, 162 and 24,576 information states. We evaluate all our policies using the NashConv metric (Lanctot et al., 2017) defined as .
In this section, we highlight two results with function approximation and illustrate the theory with tabular experiments on Kuhn Poker (figure 2). A more complete empirical evaluation and the precise description of the setting is available in appendix K.
We found that decaying the regularization exponentially from an initial value to a target value (we looked at values ) is an effective empirical method. In figure 3 (top plot), we represent the NashConv as a function of the number of steps. We achieve our best performance for with a NashConv of . This outperforms the results of NFSP (Heinrich & Silver, 2016), which has a best result of 0.12 in NashConv (0.06 of exploitability reported in the paper) and the state of the art algorithms implemented in Openspiel, which are no better than in NashConv. However, for low choices of the algorithm might diverge.
2 Iteration over the Regularization
As we have seen in section 6, the convergence to an exact equilibrium can be achieved by iteratively adapting the the reward. In the experiment (Fig. 3 bottom plot), we change the reward periodically every -steps between steps we linearly interpolate between and and in interval we use the transformed reward . As shown in Fig. 3 (bottom plot), this technique allows convergence for very high . This is quite an advantage as the method will be more robust to the choice of that hyper-parameter.
Conclusion
We generalize the Poincaré recurrence result for FoReL from 2-player normal-form zero-sum games to sequential imperfect information games with a monotonicity condition. Although this is a generalization of a negative convergence result, we show that several reward transformations can guarantee convergence to a slightly modified equilibrium. We also show how to recover the original equilibrium of the game (when it is interior). Finally, based on these techniques we improve the state-of-the-art in model-free deep reinforcement learning in imperfect information games.
Since this work only focuses on FoReL, we aim to analyze the behavior of other dynamics in the sequential case from a dynamical systems perspective in future work. Fictitious play or softmax -learning have been theoretically considered in normal form games and their analysis with Lyapunov methods remains to be done in the IIG case. Furthermore, the role of regularization for convergence in games needs to be studied more systematically in other settings. Ideas like regularization could also be studied in for example Generative Adversarial Networks.
References
Appendix A Proof of Lemma 3.1
Let’s write and let’s notice that for all , we have that and thus for all ,
Appendix B The system is equivalent to FoReL dynamics and is Divergence-free (lemma 4.1)
For all the variable:
is an autonomous dynamical system as is a function of . Let us write it we have .
Finally, , (where ) is independent of as does not depend on .
Thus we have . This proves that the and that the dynamics is incompressible.
Appendix C Proof Strong Lyapunov Function
for all in , the tangent space of , we have that if is in the interior of (see (Hofbauer & Sandholm, 2002) for the statement of this property). Thus, for all there exists a such that
Where is the Bregman divergence associated with . If is the entropy, we the following equality .
Appendix D Proof of Lemma 6.1
Let us write and
Let us write the value function for the reward and policy will be written
Now combining we have:
And finally we have the desired property:
And we get the result by summing over the players:
Appendix E Proof of Lemma 4.2
If the equilibrium is interior, then .
First let us show that :
Since is a Nash equilibrium we always have . Let us suppose that there exists an information state such that does not have the same values for all actions and that the equilibrium is of full support. Then a greedy policy on that state (and on the other states) should improve the value for player . This would contradict being a Nash equilibrium. This proves that all Q-values are equals for every states . Then for all states.
This concludes the proof that for all , . ∎
Appendix F Reward Transformation in Monotone Games
The reward transformation that can be considered are the following:
For the game defined on reward
Thus if for the game defined with reward , then for the game defined on reward the monotonicity is also .
Appendix G Reward Transformation in Zero-Sum Games
The game is still zero-sum so the monotonicity is still zero.
As in that case for all .
Appendix H Convergence to a Nash
The proof of the convergence to an exact Nash uses similar arguments used to prove convergence for strict Lyapunov functions in the discrete vase. From lemma 6.1 we know that for a policy sequence starting from being the uniform policy and is the solution of the game with the reward transformation . In this section, we will call this map (and is the equilibrium of the game defined on ). We will show that will converge to a Nash equilibrium of the game .
Second we prove that ,
The second step is enough to prove that converges to a value . The last step proves by contradiction that can’t be anything but .
The first step is to show that the map which associate to the Nash equilibrium over the game defined over is continuous.
Then for all , we have
Let us write now and the fixed point of the dynamic defined in lemma 4.1 and and their corresponding Lyapunov function and and .
Let have (where is an open set). Furthermore let us suppose that for all there exists such that for all and .
The function is locally Lipschitz of constant in .
As we can bound
This imply that .
This finally imply that the map is continuous.
We have seen that the following equality holds (in lemma 6.1):
And where if the game is monotone.
First let us write the set of Nash equilibrium if the game defined on reward .
The Goal of this section is to prove that that for all
The first step of our proof is to show if there exists a such that , then .
To do so, we first need to prove a serie of technical lemma.
For all and for all we have:
Let’s write
Let be a policy. If for all and such that then is a Nash equilibrium.
Let suppose that for all and we have
If is not a Nash equilibrium, then there exists and such that
This is a direct consequence of lemma H.2 ∎
If , then is a Nash equilibrium of the game defined on .
First we will write () to be the value function (-function) with respect to the reward .
The reader will notice that since then .
As is a Nash equilibrium for the reward , then
So there exists and such that . And finally there exists such that which contradicts the fact that is a Nash for the game on reward .
From theorem H.1 we can conclude that for all , we have this directly imply that for all we have .
H.3 Convergence to the Nash
We want to show that the sequence of policies converges to a Nash equilibrium of the game. And we suppose that all policies are interior.
Under these conditions, we have the following properties:
is a continuous map on the interior of the simplex (see section H.1),
for all we have .
is a positive function infinite on the border of the simplex continuous in .
is continuous in .
Let us write and . For all finite the set is closed and bounded set (and is an open bounded set). Then is a compact set.
Let us consider that . Since then the sequence of converges to .
By contradiction let us suppose that . This means that all the are all in the closed set . The set is bounded and thus is a compact. The image of through (which is a continuous map) is a compact and . This means that
This contradicts the fact that as there exists such that .
In the end converges to and converges to
Appendix I Monotone Games
In this section, we prove that zero-sum, zero-sum -player polymatrix games and games where the profit of one player is decoupled from the interaction with the opponent are monotone.
(i) zero-sum two-player games, i.e., , the monotonicity condition becomes:
It is easy to notice that as
(iii) in games where the profit of one player is decoupled from the interaction with the opponents, i.e., when the value can be decomposed in .
In this case
Appendix J Empirical set up
The update on a -function is done such as to minimize the -norm between a retrace target (Espeholt et al., 2018) constructed using the sequence or policies and rewards (written ).
J.2 Low Variance Unbiased Estimate of the Expected Payoff
This version of NeuRD uses an unbiased estimate and low-variance of the return (Schmid et al., 2019). We will account that the policy we want to evaluate can be different from the one we are sampling and the unbiased return is computed as follow in the case of the reward transform for zero-sum games as follows:
By convention, we will have that
J.3 NeuRD update
In the second step we correct for the reach probability:
Where and are the policies at the player’s turn.
The policy update follows the following equation:
Where is the logit of policy and . The NeuRD update rule require an additional clipping parameter to avoid numerical instabilities. We leave the reader to (Omidshafiei et al., 2019).
Last, we obtained the exploration policy by doing an epsilon greedy policy .
Appendix K Experiments
In this section we present experiments on Kuhn poker and Leduc poker that illustrate the convergence property for the dynamics on the transformed reward.
The two following figures illustrate the method described in section 5. The following experiment Shows the FoReL dynamics on Kuhn poker :
And the following experiment Shows the FoReL dynamics on Leduc poker :
K.1.2 Tabular Experiments With a Fixed Regularization (reward transformation for monotone games)
The two following figures illustrate the method described in section 5. The following experiment Shows the FoReL dynamics on Kuhn poker :
And the following experiment Shows the FoReL dynamics on Leduc poker :
The two following figures illustrate the method described in section 6. And the following experiment Shows the FoReL dynamics on Kuhn poker :
And the following experiment Shows the FoReL dynamics on Leduc poker :
K.2 Deep Reinforcement Learning Experiments with player only regularization
In this section, we run NeuRD on Leduc poker, Kuhn poker, Liars Dice and GoofSpiel with the reward transform for monotone games. The reward is adapted every 75000 steps.
In these experiments, we run NeuRD on Leduc poker, Kuhn poker, Liars Dice and GoofSpiel with the reward transform for monotone games with a constant regularization.
In these experiments, we run NeuRD on Leduc poker, Kuhn poker, Liars Dice and GoofSpiel with the reward transform for monotone games with an exponential decay regularization to the regularization on the label.
K.3 Deep Reinforcement Learning Experiments with two player regularization
In these experiments, we run NeuRD on Leduc poker, Kuhn poker, Liars Dice and GoofSpiel with the reward transform for zero-sum games with an exponential decay regularization to the regularization on the label.
K.4 Deep Reinforcement Learning Experiments with two player regularization with a large batch
In these experiments, we run NeuRD on Leduc poker, Kuhn poker, Liars Dice and GoofSpiel with the reward transform for zero-sum games with an exponential decay regularization to the regularization on the label.