Computing Approximate Equilibria in Sequential Adversarial Games by Exploitability Descent

TL;DR

This paper introduces exploitability descent, a novel algorithm for approximating equilibria in two-player zero-sum extensive-form games with imperfect information, demonstrating convergence to Nash equilibrium through direct policy optimization.

Contribution

The paper proposes exploitability descent, a new algorithm with proven convergence to Nash equilibrium, outperforming existing methods in certain imperfect information games with function approximation.

Findings

Converges asymptotically to zero exploitability.

Outperforms tabular algorithms in some games with function approximation.

First to show such results in imperfect information games among this class.

Abstract

In this paper, we present exploitability descent, a new algorithm to compute approximate equilibria in two-player zero-sum extensive-form games with imperfect information, by direct policy optimization against worst-case opponents. We prove that when following this optimization, the exploitability of a player's strategy converges asymptotically to zero, and hence when both players employ this optimization, the joint policies converge to a Nash equilibrium. Unlike fictitious play (XFP) and counterfactual regret minimization (CFR), our convergence result pertains to the policies being optimized rather than the average policies. Our experiments demonstrate convergence rates comparable to XFP and CFR in four benchmark games in the tabular case. Using function approximation, we find that our algorithm outperforms the tabular version in two of the games, which, to the best of our knowledge, is the first such result in imperfect information games among this class of algorithms.

Figures

Equations

$$v_{i,\mathbf{\pi }}={\mathbb{E}}_{z\sim \mathbf{\pi }}[u_i(z)],$$

$$q_{i,\mathbf{\pi }}(s,a)=$$

$$=$$

$${\nabla }_{{\theta }_i}{v}_{i,{\mathbf{\pi }}_{\mathbf{\theta }}}$$

$${\theta }_i$$

$${\mathbf{q}}^{\mathbf{b}}(s)=\{q_{i,({\mathbf{\pi }}_{\theta }^{t-1},{\mathbf{b}}_{-i}^t)}(s,a){\}}_{a\in \mathcal{A}},$$

$${\theta }_s^t$$

$${\mathbf{q}}^{\mathbf{b}}(s)=\{q_{i,\mathbf{\pi }}^c(({\mathbf{\pi }}_{\mathbf{\theta }}^{t-1},{\mathbf{b}}_{-i}^t),s,a){\}}_{a\in \mathcal{A}},$$

$${\mathbf{\theta }}_s^t={\mathbf{\theta }}_s^{t-1}+{\alpha }^t⟨{\nabla }_{{\mathbf{\theta }}_s}{\mathbf{\pi }}_{\mathbf{\theta }}^{t-1}(s),{\mathbf{q}}^{\mathbf{b}}(s)⟩,$$

$${\nabla }_{{\theta }_i}{v}_{i,({\pi }_{{\theta }_i},b_{-i}({\pi }_{{\theta }_i}))}\in \partial \underset{{\pi }_{-i}}{\min }{v}_{i,({\pi }_{{\theta }_i},{\pi }_{-i})}.$$

$${\mathbf{\pi }}_i^t(s)={\Pi }_{{\ell }_2}\left({\mathbf{\pi }}_i^{t-1}(s)+{\alpha }^t{\mathbf{q}}^{c,\mathbf{b}}(s)\right).$$

$$\text{textsc}NashConv({\pi }_{{\theta }_i},{\pi }_{{\theta }_{-i}})=\sum _i\underset{{\pi }_i^{\prime }}{\max }{v}_{i,({\pi }_i^{\prime },{\pi }_{{\theta }_{-i}})}-v_{i,\mathbf{\pi }}$$

$$=\sum _i\underset{{\pi }_i^{\prime }}{\max }{v}_{i,({\pi }_i^{\prime },{\pi }_{{\theta }_{-i}})}=\sum _i-\underset{{\pi }_i^{\prime }}{\min }-v_{i,({\pi }_i^{\prime },{\pi }_{{\theta }_{-i}})}$$

$$=-(\underset{{\pi }_1^{\prime }}{\min }{v}_{2,({\pi }_{{\theta }_2},{\pi }_1^{\prime })}+\underset{{\pi }_2^{\prime }}{\min }{v}_{1,({\pi }_{{\theta }_1},{\pi }_2^{\prime })})$$

$${\partial }_{\mathbf{\theta }}\sum _i\underset{{\pi }_i^{\prime }}{\max }{v}_{i,({\pi }^{{}^{\prime }i},{\pi }_{{\theta }_i}^{-i})}-v_{i,\mathbf{\pi }}$$

$$=-\left({\partial }_{{\theta }_2}\underset{{\pi }_1^{\prime }}{\min }{v}_{2,({\pi }_{{\theta }_2},{\pi }_1^{\prime })}+{\partial }_{{\theta }_2}\underset{{\pi }_2^{\prime }}{\min }{v}_{1,({\pi }_{{\theta }_1},{\pi }_2^{\prime })}\right).$$

$$R_i^T=\underset{{\mathbf{\pi }}_i}{\max }\sum _{t=1}^T\left(v_{i,({\mathbf{\pi }}_i,{\mathbf{\pi }}_{-i}^t)}-v_{i,{\mathbf{\pi }}^t}\right).$$

$$R^T=\sum _{t=1}^T\ell ({\mathbf{\theta }}^t)-\underset{{\mathbf{\theta }}^{\ast }\in \Theta }{\inf }\sum _{t=1}^T\ell ({\mathbf{\theta }}^{\ast }).$$

$$\ell (\hat{\mathbf{\theta }})-\underset{{\mathbf{\theta }}^{\ast }\in \Theta }{\inf }\ell ({\mathbf{\theta }}^{\ast })\le \frac{R^T}{T}.$$

$$R^T$$

$${\ell }_i({\pi }^{\ast })-\underset{{\pi }_i^{\prime }}{\min }{\ell }_i({\pi }_i^{\prime },{\pi }_{-i})$$

$$\le$$

$$R_i^T\le |{\mathcal{S}}_i|\left(\sqrt{T}+(\sqrt{T}-\frac{1}{2})|{\mathcal{A}}_i|({\Delta }_{u_i}{)}^2\right).$$

$${\pi }_{\text{hedge}}^T$$

$${\mathbf{\theta }}^t$$

$$={\mathbf{\theta }}^{t-1}+\alpha {\mathbf{\upsilon }}^t$$

$$={\mathbf{\theta }}^0+\alpha \sum _{i=1}^t{\mathbf{\upsilon }}^i,$$

$${\mathbf{\pi }}_{\text{MD}}^t$$

$${\mathbf{\theta }}^t$$

$${\pi }_{\text{PG}}^t$$

$$\frac{\partial \mathbf{\pi }}{\partial {\theta }_a}\cdot \mathbf{\upsilon }$$

$$=\sum _{a^{\prime }\in \mathcal{A}}\pi (a^{\prime })\left[\text{mathds}{1}_{a^{\prime }=a}-\pi (a)\right]{\upsilon }_{a^{\prime }}$$

$$=\pi (a)\left[1-\pi (a)\right]{\upsilon }_a-\sum _{a^{\prime }\in \mathcal{A},a^{\prime }\ne a}\pi (a^{\prime })\pi (a){\upsilon }_{a^{\prime }}$$

$$=\pi (a)\left[\left[1-\pi (a)\right]{\upsilon }_a-\sum _{a^{\prime }\in \mathcal{A},a^{\prime }\ne a}\pi (a^{\prime }){\upsilon }_{a^{\prime }}\right]$$

$$=\pi (a)\left[{\upsilon }_a-\pi (a){\upsilon }_a-\sum _{a^{\prime }\in \mathcal{A},a^{\prime }\ne a}\pi (a^{\prime }){\upsilon }_{a^{\prime }}\right]$$

$$=\pi (a)\left[{\upsilon }_a-\sum _{a^{\prime }\in \mathcal{A}}\pi (a^{\prime }){\upsilon }_{a^{\prime }}\right].$$

Full text

1 Introduction

Extensive-form games model sequential interactions between multiple agents, each of which maximize their own utility. Classic examples are perfect information games (e.g. chess and Go), which have served as milestones for measuring the progress of artificial intelligence Campbell et al. (2002); Silver et al. (2016). When there are simultaneous moves, such as in Markov games, the players may need stochastic policies to guarantee their worst-case expected utility, and must use linear programming at each state for value back-ups. Computing policies for imperfect information games is much more difficult: no Bellman operator exists, so approximate dynamic programming is not applicable; exact equilibrium solutions can be found by sequence-form linear programming Koller et al. (1994); Shoham and Leyton-Brown (2009), but these techniques do not scale to very large games.

The challenge domain for imperfect information has been computer Poker, which has driven much of the progress in computational approaches to equilibrium-finding Rubin and Watson (2011). While there are gradient descent techniques that can find an $\epsilon$-Nash equilibrium in $O(\frac{1}{\epsilon})$ iterations Hoda et al. (2007), the dominant technique has been counterfactual regret minimization (CFR) Zinkevich et al. (2008). Based on CFR, recent techniques have solved heads-up limit Texas Hold’em Bowling et al. (2015) and beat human professionals in no-limit Texas Hold’em Moravčík et al. (2017); Brown and Sandholm (2017).

Other techniques have emerged in recent years, based first on fictitious play (XFP) Heinrich et al. (2015), and generalized to double oracle and any meta-game solver over sets of policies Lanctot et al. (2017). Both require a subroutine that computes a best response (an “oracle”). Here, reinforcement learning can be used to compute approximate oracles, and function approximation can be used to generalize over the state space without domain-specific abstraction mechanisms. Hence, deep neural networks can trained from zero knowledge as in AlphaZero Silver et al. (2018). Policy gradient techniques are also compatible with function approximation in this setting Srinivasan et al. (2018). Combining data buffers with CFR using regression to predict regrets has also shown promise in medium-sized poker variants Waugh et al. (2015); Brown et al. (2019).

In this paper, we introduce a new algorithm for computing approximate Nash equilibria. Like XFP, best responses are computed at each iteration. Unlike XFP, players optimize their policies directly against their worst-case opponent. When using tabular policies and $\ell_{2}$ projections after policy updates, the sequence of policies will contain an $\epsilon$-Nash equilibrium, unlike CFR and XFP that only converge-in-average. Our algorithm works well with function approximation, as the problem can be expressed directly as a policy gradient optimization. Our experiments show convergence rates comparable to XFP and CFR in the tabular setting, exhibit generalization over the state space using neural networks in four different games.

At the time of original submission, we were unaware of a similar algorithm recently presented at the Deep RL Workshop NeurIPS 2018: Self-Play Against a Best Response (SPAR) Tang et al. (2018). The work we present in this paper was done independently. In this paper, we provide convergence guarantees, as well as results in both the tabular and neural network cases. We do so on four benchmark games (both commonly used poker benchmarks used in Tang et al. (2018) and two additional games), whereas results of SPAR focus on the sample-based setting not covered in this paper.

2 Background and Terminology

An extensive-form game describes a sequential interaction between players $i\in\{1,2,\cdots,n\}\cup\{c\}$, where $c$ is considered a special player called chance with a fixed stochastic policy that determines the transition probabilities given states and actions. We will often use $-i$ to refer to all the opponents of $i$. In this paper, we focus on the $n=2$ player setting.

The game starts in the empty history $h=\emptyset$. On each turn, a player $i$ chooses an action $a\in\mathcal{A}_{i}$, changing the history to $h^{\prime}=ha$. Here $h$ is called a prefix history of $h^{\prime}$, denoted $h\sqsubset h^{\prime}$. The full history is sometimes also called a ground state because it uniquely identifies the true state, since chance’s actions are included. In poker, for example, a ground state would include all the players’ private cards. We define an information state $s\in\mathcal{S}$ for player $i$ as the state as perceived by an agent which is consistent with its observations. Formally, each $s$ is a set of histories, specifically $h,h^{\prime}\in s\Leftrightarrow$ the sequence of of player $i$’s observations along $h$ and $h^{\prime}$ are equal. In poker, an information state groups together all the histories that differ only in the private cards of $-i$. Denote $\mathcal{Z}$ the set of terminal histories, each corresponding to the end of a game, and a utility to each player $u_{i}(z)$ for $z\in\mathcal{Z}$. We also define $\tau(s)$ as the player whose turn it is at $s$, and $\mathcal{Z}(h)$ the subset of terminal histories that share $h$ as a prefix.

Since players cannot observe the ground state $h$, policies are defined as $\pi_{i}:\mathcal{S}_{i}\rightarrow\Delta(\mathcal{A}_{i})$, where $\Delta(\mathcal{A}_{i})$ is the set of probability distributions over $\mathcal{A}_{i}$. Each player tries to maximize their expected utility given the initial starting history $\emptyset$. We assume finite games, so every history $h$ is bounded in length. The expected value of a joint policy ${\bm{\pi}}$ (all players’ policies) for player $i$ is defined as

[TABLE]

where the terminal histories $z\in\mathcal{Z}$ are composed of actions drawn from the joint policy. We also define state-action values for joint policies. The value $q_{i,{\bm{\pi}}}(s,a)$ represents the expected return starting at state $s$, taking action $a$, and playing ${\bm{\pi}}$:

[TABLE]

where $q_{i,{\bm{\pi}}}(h,a)=\mathbb{E}_{z\sim{\bm{\pi}}}[u_{i}(z)~{}|~{}ha\sqsubseteq z]=\sum_{h\in s,z\in\mathcal{Z}(h)}\eta_{{\bm{\pi}}}(h,z)u_{i}(z)$ is the expected utility of the ground state-action pair $(h,a)$, and $\eta_{\bm{\pi}}(h)$ is the probability of reaching $h$ under the policy ${\bm{\pi}}$. We make the common assumption that players have perfect recall, i.e. they do not forget anything they have observed while playing. Under perfect recall, the distribution of the states can be obtained only from the opponents’ policies using Bayes’ rule (see (Srinivasan et al., 2018, Section 3.2)).

Each player $i$ tries to find a policy that maximizes their own value $v_{i,{\bm{\pi}}}$. However, this is difficult to do independently since the value depends on the joint policy, not just player $i$’s policy. A best response policy for player $i$ is defined to be $b_{i}({\bm{\pi}}_{-i})\in\textsc{BR}({\bm{\pi}}_{-i})=\{{\bm{\pi}}_{i}~{}|~{}v_{i,({\bm{\pi}}_{i},{\bm{\pi}}_{-i})}=\max_{{\bm{\pi}}_{i}^{\prime}}v_{i,({\bm{\pi}}_{i}^{\prime},{\bm{\pi}}_{-i})}\}$. Given a joint policy ${\bm{\pi}}$, the exploitability of a policy ${\bm{\pi}}_{-i}$ is how much the other player could gain if they switched to a best response: $\delta_{i}({\bm{\pi}})=\max_{{\bm{\pi}}^{\prime}_{i}}v_{i,({\bm{\pi}}^{\prime}_{i},{\bm{\pi}}_{-i})}-v_{i,{\bm{\pi}}}$. In two-player zero-sum games, an $\epsilon$-minmax (or $\epsilon$-Nash equilibrium) policy is one where $\max_{i}\delta_{i}({\bm{\pi}})\leq\epsilon$. A Nash equilibrium is achieved when $\epsilon=0$. A common metric to measure the distance to Nash is NashConv$({\bm{\pi}})=\sum_{i}\delta_{i}({\bm{\pi}})$.

2.1 Extensive-Form Fictitious Play (XFP)

Extensive-form fictitious play (XFP) is equivalent to standard fictitious play, except that it operates in the extensive-form representation of the game Heinrich et al. (2015). In fictitious play, the joint policy is initialized arbitrarily (e.g. uniform random distribution at each information state), and players learn by aggregating best response policies.

The extensive-form version, XFP, requires game-tree traversals to compute the best responses and specific update rules that account for the reach probabilities to ensure that the updates are equivalent to the classical algorithm, as described in (Heinrich et al., 2015, Section 3). Fictitious play converges to a Nash equilibrium asymptotically in two-player zero-sum games. Sample-based approximations to the best response step have also been developed Heinrich et al. (2015) as well as function approximation methods to both steps Heinrich and Silver (2016). Both steps have also been generalized to other best response algorithms and meta-strategy combinations Lanctot et al. (2017).

2.2 Counterfactual Regret Minimization (CFR)

CFR decomposes the full regret computation over the tree into per information-state regret tables and updates Zinkevich et al. (2008). Each iteration traverses the tree to compute the local values and regrets, updating cumulative regret and average policy tables, using a local regret minimizer to derive the current policies at each information state.

The quantities of interest are counterfactual values, which are similar to $Q$-values, but differ in that they weigh only the opponent’s reach probabilities, and are not normalized. Formally, let $\eta_{-i,{\bm{\pi}}}(h)$ be only the opponents’ contributions to the probability of reaching $h$ under ${\bm{\pi}}$. Then, similarly to equation 2, we define counterfactual values: $q^{c}_{i,{\bm{\pi}}}(s,a)=\sum_{h\in s}\eta_{-i,{\bm{\pi}}}(h)q_{i,{\bm{\pi}}}(h,a)$, and $v^{c}_{i,{\bm{\pi}}}(s)=\sum_{a\in\mathcal{A}_{i}}\pi_{i}(s,a)q^{c}_{i,{\bm{\pi}}}(s,a)$. On each iteration $k$, with a joint policy ${\bm{\pi}}^{k}$, CFR computes a counterfactual regret $r(s,a)=q^{c}_{i,{\bm{\pi}}^{k}}(s,a)-v^{c}_{i,{\bm{\pi}}^{k}}(s)$ for all information states $s$, and a new policy from the cumulative regrets of $(s,a)$ over the iterations using regret-matching Hart and Mas-Colell (2000). The average policies converge to an $\epsilon$-Nash equilibrium in $O(|\mathcal{S}_{i}|^{2}|\mathcal{A}_{i}|/\epsilon^{2})$ iterations.

2.2.1 CFR Versus a Best Response Oracle (CFR-BR)

Instead of both players employing CFR (CFR-vs-CFR), each player can use CFR versus their worst-case (best response) opponent, i.e. simultaneously running CFR-vs-BR and BR-vs-CFR. This is the main idea behind counterfactual regret minimization against a best response (CFR-BR) algorithm Johanson et al. (2012). The combined average policies of the CFR players is also guaranteed to converge to an $\epsilon$-Nash equilibrium. In fact, the current strategies also converge with high probability. Our convergence analyses are based on CFR-BR, showing that a policy gradient versus a best responder also converges to an $\epsilon$-Nash equilibrium.

2.3 Policy Gradients in Games

We consider policies $\bm{\pi}_{\bm{\theta}}=(\pi_{i,\theta_{i}})_{i}$ each policy are parameterized by a vector of parameter $(\theta_{i})_{i}=\bm{\theta}$. Using the likelihood ratio method, the gradient of $v_{i,\bm{\pi_{\theta}}}$ with respect to the vector of parameters $\theta_{i}$ is:

[TABLE]

This result can be seen as an extension of the policy gradient Theorem Sutton et al. (2000); Glynn and L’ecuyer (1995); Williams (1992); Baxter and Bartlett (2001) to imperfect information games and has been used under several forms: for a detailed derivation, see (Srinivasan et al., 2018, Appendix D).

The critic ($q_{i,\bm{\pi_{\theta}}}$) can be estimated in many ways (Monte Carlo Return Williams (1992) or using a critic for instance in Srinivasan et al. (2018) in the context of games. Then:

[TABLE]

where $\alpha$ is the learning rate used by the algorithm and $\hat{q}_{i,\bm{\pi_{\theta}}}(s_{l},a)$ is the estimation of the return used.

3 Exploitability Descent

Exploitability Descent (ED) follows the basic form of the classic convex-concave optimization problem for solving matrix games Gale et al. (1951); Boyd and Vandenberghe (2004). Conceptually, the algorithm is uncomplicated and shares the outline of fictitious play: on each iteration, there are two steps that occur for each player. The first step is identical to fictitious play: compute the best response to each player’s policy. The second step then performs gradient ascent on the policy to increase each player’s utility against the respective best responder (aiming to decrease each player’s exploitability).

The change in the second step is important for two reasons. First, it leads to a convergence of the policies that are being optimized without having to compute an explicit average policy, which is complex in the sequential setting. Secondly, the policies can now be easily parameterized (i.e. using e.g. deep neural networks) and trained using policy gradient ascent without storing a large buffer of previous data.

The general algorithm is outlined in Algorithm 2, where $\alpha^{t}$ the learning rate on iteration $t$. Two steps (lines 2 and 2) are intentionally unspecified: we will show properties for two specific instantiations of this general ED algorithm. The quantity $\mathbf{q}^{\bm{b}}$ refers to a set of expected values for player $i=\tau(s)$, one for each action at $s$ using ${\bm{\pi}}^{t-1}_{i}$ against a set of individual best responses. The GradientAscent update step unspecified for now as we will describe several forms, but the main idea is to increase/decrease the probability of higher/lower utility actions via the gradients of the value functions, and project back to the space of policies.

3.1 Tabular ED with $q$-Values and $\ell_{2}$ Projection

For a vector of $|\mathcal{A}|$ real numbers $\boldsymbol{\theta}_{s}$, define the simplex as $\Delta_{s}=\{\boldsymbol{\theta}_{s,a}~{}|~{}\boldsymbol{\theta}_{s}\geq\mathbf{0},\sum_{a}\theta_{s,a}=1\}$, and the $\ell_{2}$ projection as $\Pi_{\ell_{2}}(\boldsymbol{\theta}_{s})=\operatornamewithlimits{argmin}_{\boldsymbol{\theta}_{s}^{\prime}\in\Delta_{s}}||\boldsymbol{\theta}_{s}^{\prime}-\boldsymbol{\theta}_{s}||_{2}$.

Let ${\bm{\pi}}_{\boldsymbol{\theta}}$ be a joint policy parameterized by $\boldsymbol{\theta}$, and ${\bm{\pi}}_{\boldsymbol{\theta}_{i}}$ refer to the portion of player $i$’s parameters (i.e. in tabular form $\{\boldsymbol{\theta}_{s}~{}|~{}\tau(s)=i\}$). Here each parameter is a probability of an action at a particular state: $\theta_{s,a}=\pi_{\boldsymbol{\theta}}(s,a)$. We refer to TabularED($q$, $\ell_{2}$) as an instance of exploitability descent with

[TABLE]

and the policy gradient ascent update defined to be

[TABLE]

where the Jacobian $\nabla_{\boldsymbol{\theta}_{s}}{\bm{\pi}}^{t-1}_{\boldsymbol{\theta}}(s)$ is an identity matrix because each parameter $\theta_{s,a}$ corresponds directly to the probability $\pi_{\boldsymbol{\theta}}(s,a)$, and $\langle\cdot,\cdot\rangle$ is the usual matrix inner product.

3.2 Tabular ED with Counterfactual Values and Softmax Transfer Function

For some vector of real numbers, ${\boldsymbol{\theta}_{s}}$, define softmax$(\boldsymbol{\theta}_{s})=\{\Pi_{\text{sm}}(\boldsymbol{\theta}_{s})\}_{a}=\{\exp(\theta_{s,a})/\sum_{a^{\prime}}\exp(\theta_{s,a^{\prime}})\}_{a}$. Re-using the tabular policy notation from the previous section, we now define a different instance of exploitability descent. We refer to TabularED($q^{c}$, softmax) as the algorithm that specifies ${\bm{\pi}}_{\boldsymbol{\theta}}(s)=\Pi_{\text{sm}}(\boldsymbol{\theta}_{s})$,

[TABLE]

and the policy parameter update as

[TABLE]

where $\nabla_{\boldsymbol{\theta}_{s}}{\bm{\pi}}^{t-1}_{\boldsymbol{\theta}}(s)$ represents the Jacobian of softmax.

3.3 Convergence Analyses

We now analyze the convergence guarantees of ED. We give results for two cases: first, in cyclical perfect information games and Markov games, and secondly imperfect information games. All the proofs are found in the Appendix A.

3.3.1 Cyclical Perfect Information Games and Markov Games

The following result extends the policy gradient theorem Sutton et al. (2000); Glynn and L’ecuyer (1995); Williams (1992); Baxter and Bartlett (2001) to the zero-sum two-player case. It proves that a generalized gradient of the worst-case value function can be estimated from experience as in the single player case.

Theorem 1** (Policy Gradient in the Worst Case).**

The gradient of policy $\bm{\pi_{\theta_{i}}}$’s value, $v_{i,(\bm{\pi_{\theta_{i}}},\bm{b})}$, against a best response, $\bm{\beta}\doteq\bm{b_{-i}(\pi_{\theta_{i}})}\in\textsc{BR}(\pi_{\theta_{i}})$ is a generalized gradient (see Clarke (1975)) of $\bm{\pi_{\theta_{i}}}$’s worst-case value function,

[TABLE]

All of the proofs are found in Appendix A of the technical report version of the paper Lockhart et al. (2019).

This theorem is a natural extension of the policy gradient theorem to the zero-sum two-player case. As in policy gradient, this process is only guaranteed to converge to a local maximum of the worst case value $\min_{\pi_{-i}}v_{i,(\pi_{\theta_{i}},\pi_{-i})}$ of the game but not necessarily to an equilibrium of the game. An equilibrium of the game is reached when the two following conditions are met simultaneously: (1) if the policy is tabular and (2) if all states are visited with at least some probability for all policies. This statement is proven in Appendix D.

The method is called exploitability descent because policy gradient in the worst case minimizes exploitability. In a two-player, zero-sum game, if both players independently run ED, NashConv is locally minimized.

Lemma 1**.**

In the two-player zero-sum case, simultaneous policy gradient in the worst case locally minimizes NashConv.

3.3.2 Imperfect Information Games

We now examine convergence guarantees in the imperfect information setting. There have two main techniques used to solve adversarial games in this case: the first is to rely on the sequence-form representation of policies which makes the optimization problem convex Koller et al. (1994); Hoda et al. (2007). The second is to weight the values by the appropriate reach probabilities, and employ local optimizers Zinkevich et al. (2008); Johanson et al. (2012). Both take into account the probability of reaching information states, but the latter allows a convenient tabular policy representation.

We prove finite time exploitability bounds for TabularED($q$, $\ell_{2}$), and we relate TabularED($q^{c}$, softmax) to a similar algorithm that also has finite time bounds.

The convergence analysis is built upon two previous results: the first is CFR-BR Johanson et al. (2012). The second is a very recent result that relates policy gradient optimization in imperfect information games to CFR Srinivasan et al. (2018). The result here is also closely related to the optimization against a worst-case opponent (Waugh and Bagnell, 2014, Theorem 4), except our policies are expressed in tabular (i.e. behavioral) form rather than the sequence form.

Case**: TabularED($q$, $\ell_{2}$)**. Recall that the parameters $\boldsymbol{\theta}=\{\theta_{s,a}\}_{s\in\mathcal{S},a\in\mathcal{A}}$ correspond to the tabular policy. For convenience, let $\boldsymbol{\theta}_{s}=\{\theta_{s,a}\}_{a\in\mathcal{A}}$.

We now present the main theorem111Note that this theorem is different than the one presented in the original version of this work. Please see Appendix E for a discussion of the differences., which states that if both players optimize their policies using TabularED($q$, $\ell_{2}$), it will generate policies with decreasing regret, which combined form an approximate Nash equilibrium.

Theorem 2**.**

Let TabularED($q$, $\ell_{2}$) be described as in Section 3.1 using tabular policies and the update rule in Definition 1. In a two-player zero-sum game, if each player updates their policy simultaneously using TabularED($q$, $\ell_{2}$), if $\forall s,a\in\mathcal{S}\times\mathcal{A}:\theta_{s,a}>0$ and $\alpha^{t}=t^{-\frac{1}{2}}$, then for each player $i$: after $T$ iterations, a policy ${\bm{\pi}}_{i}^{*}\in\{{\bm{\pi}}_{i}^{1},\cdots,{\bm{\pi}}_{i}^{T}\}$ will have been generated such that ${\bm{\pi}}_{i}^{*}$ is $i$’s part of a $\frac{2\epsilon}{T}$-Nash equilibrium, where $\epsilon=|\mathcal{S}_{i}|\left(\sqrt{T}+(\sqrt{T}-\frac{1}{2})|\mathcal{A}_{i}|(\Delta_{u_{i}})^{2}\right)+O(T)$, and $\Delta_{u}=\max_{z,z^{\prime}\in\mathcal{Z}}(u_{i}(z)-u_{i}(z^{\prime}))$.

ED is computing best responses each round already, so it is easy to track the best iterate: it will simply be the one with the highest expected value versus the opponent’s best response. However, because of the $O(T)$ term, TabularED($q$, $\ell_{2}$) may not converge to an equilibrium, whereas this is guaranteed when using counterfactual values $q^{c}$ (see below).

The reasoning behind the proof can also be applied to the original CFR-BR theorem, so we present an improved guarantee, whereas the original CFR-BR theorem made a probabilistic guarantee.

Corollary 1**.**

*(Improved (Johanson et al., 2012, Theorem 4))

If player $i$ plays $T$ iterations of CFR-BR, then it will have generated a ${\bm{\pi}}^{*}_{i}\in\{{\bm{\pi}}^{1},{\bm{\pi}}^{2},\cdots,{\bm{\pi}}^{T}\}$, where ${\bm{\pi}}^{*}_{i}$ is a $2\epsilon$-equilibrium, where $\epsilon$ is defined as in (Johanson et al., 2012, Theorem 3).*

The best iterate can be tracked in the same way as ED, and the convergence is guaranteed.

Remark 1**.**

*When using $q$-values, the values are normalized by a quantity, $\mathcal{B}_{-i}({\bm{\pi}},s)$, that depends on the opponents’ policies (Srinivasan et al., 2018, Section 3.2). Therefore, the regret bound is undefined when $\mathcal{B}_{-i}({\bm{\pi}},s)=0$, which can happen when an opponent no longer plays to reach $s$.

Case**: TabularED**($q^{c}$, $\ell_{2}$). Instead of using q-values, we can implement ED with counterfactual values. In this case, TabularED with the $\ell_{2}$ projection becomes CFR-BR(GIGA), which provably converges to approximate equilibria and avoids the issued discussed in Remark 1.

Theorem 3**.**

Let TabularED($q^{c}$, $\ell_{2}$) be described as in Section 3.1 using tabular policies and the following update rule:

[TABLE]

*Then, the Theorem 2 statement, excluding the $O(T)$ term, also holds for TabularED($q^{c}$, $\ell_{2}$) .

Case**: TabularED($q^{c}$, softmax)** We now relate TabularED with counterfactual values and softmax policies closely to an algorithm with known finite time convergence bounds. For details, see Appendix C.

TabularED($q^{c}$, softmax) is still a policy gradient algorithm: it differentiates the policy (i.e. softmax function) with respect to its parameters, and updates in the direction of higher value. With two subtle changes to the overall process, we can show that the algorithm would become CFR-BR using hedge Freund and Schapire (1997) as a local regret minimizer. CFR with hedge is known to have a better bound, but has typically not performed as well as regret matching in practice, though it has been shown to work better when combined with pruning based on dynamic probability thresholding Brown et al. (2017).

Instead of policy gradient, one can use a softmax transfer function over the the sum of action values (or regrets) over time, which are the gradients of the value function with respect to the policy. Accumulating the gradients in this way, the algorithm can be recognized as Mirror Descent Nemirovsky and Yudin (1983), which also coincides with hedge given the softmax transfer Beck and Teboulle (2003). When using the counterfactual values, ED then turns into CFR-BR(hedge), which converges for the same reasons as CFR-BR(regret-matching).

We do not have a finite time bound of the exploitability of TabularED($q^{c}$, softmax) as we do for the same algorithm with an $\ell_{2}$ projection or CFR-BR(hedge). But since TabularED($q^{c}$, softmax) is a policy gradient algorithm, its policy will be adjusted toward a local optimum upon each update and will converge at that point when the gradient is zero. We use this algorithm because the policy gradient formulation allows for easily-applicable general function approximation.

4 Experimental Results

We now present our experimental results. We start by comparing empirical convergence rates to XFP and CFR in the tabular setting, following by convergence behavior when training neural network functions to approximate the policy.

In our initial experiments, we found that using $q$-values led to plateaus in convergence in some cases, possibly due to numerical instability caused by the problem outlined in Remark 1. Therefore, we present results only using TabularED($q^{c}$, softmax), which for simplicity we refer to as TabularED for the remainder of this section. We also found that the algorithm converged faster with slightly higher learning rates than the ones suggested by Section 3.3.2.

4.1 Experiment Domains

Our experiments are run across four different imperfect information games. We provide very brief descriptions here; see Appendix B as well as Kuhn (1950); Southey et al. (2005) and  (Lanctot, 2013, Chapter 3) for more detail.

Kuhn poker is a simplified poker game first proposed by Harold Kuhn Kuhn (1950) Leduc poker is significantly larger game with two rounds and a 6-card deck in two suits, e.g. {JS,QS,KS, JH,QH,KH}. Liar’s Dice(1,1) is dice game where each player gets a single private die, rolled at the start of the game, and players proceed to bid on the outcomes of all dice in the game. Goofspiel is a card game where players try to obtain point cards by bidding simultaneously. We use an imperfect information variant where bid cards are unrevealed.

4.2 Convergence Results

We now present empirical convergence rates to $\epsilon$-Nash equilibria. The main results are depicted in Figure 1.

For the neural network experiments, we use a single policy network for both players, which takes as input the current state of the game and whose output is a softmax distribution over the actions of the game. The state of the game is represented in a game-dependent fashion as a fixed-size vector of between 11 and 52 binary bits, encoding public information, private information, and the game history.

The neural network consists of a number of fully-connected hidden layers, each with the same number of units and with rectified linear activation functions after each layer. A linear output layer maps from the final hidden layer to a value per action. The values for the legal actions are selected and mapped to a policy using the softmax function.

At each step, we evaluate the policy for every state of the game, compute a best response to it, and evaluate each action against the best response. We then perform a single gradient descent step on the loss function: $-\sum_{s}{\bm{\pi}}_{i}(s)\cdot\left(\mathbf{q}^{b}(s)-B(s)\right)+w_{r}\frac{1}{n}\sum_{i}\boldsymbol{\theta}_{i}^{2}$, where the final term is a regularization for all the neural network weights, and the baseline $B(s)$ is a computed constant (i.e. it does not contribute to the gradient calculation) with $B(s)={\bm{\pi}}_{i}(s)\cdot\mathbf{q}^{\bm{b}}(s)$. We performed a sweep over the number of hidden layers (from 1 to 5), the number of hidden units (64, 128 or 256), the regularization weight ($10^{-7},10^{-6},10^{-5},10^{-4}$), and the initial learning rate (powers of 2). The plotted results show the best values from this sweep for each game.

4.3 Discussion

There are several interesting observations to make about the results. First, the convergence of the neural network policies is more erratic than the tabular counterparts. However, in two games the neural network policies have learned more accurate approximate equilibria than any of the tabular algorithms for the same number of iterations. The network could be generalizing across the state space (discovering patterns) in a way that is not possible in the tabular case, despite raw input features.

Although Tabular ED and XFP have roughly the same convergence rate, the respective function approximation versions have an order of magnitude difference in speed, with Neural ED reaching an exploitability of $0.08$ in Leduc Poker after $10^{5}$ iterations, a level which NFSP reaches after approximately $10^{6}$ iterations Heinrich and Silver (2016). Neural ED and NFSP are not directly comparable as NFSP is computing an approximate equilibrium using sampling and RL while ED uses true best response. However, NFSP uses a reservoir buffer dataset of 2 million entries, whereas this is not required in ED.

5 Conclusion

We introduce Exploitability Descent (ED) that optimizes its policy directly against worst-case opponents. In cyclical perfect information and Markov games, we prove that ED policies converge to strong policies that are unexploitable in the tabular case. In imperfect information games, we also present finite time exploitability bounds for tabular policies. While the empirical convergence rates using tabular policies are comparable to previous algorithms, the policies themselves provably converge. So, unlike XFP and CFR, there is no need to compute the average policy. Neural network function approximation is applicable via direct policy gradient ascent, also avoiding domain-specific abstractions, or the need to store large replay buffers of past experience, as in neural fictitious self-play Heinrich and Silver (2016), or a set of past networks, as in PSRO Lanctot et al. (2017).

In some of our experiments, neural networks learned lower-exploitability policies than the tabular counterparts, which could be an indication of strong generalization potential by recognizing similar patterns across states. There are interesting directions for future work: using approximate best responses and sampling trajectories for the policy optimization in larger games where enumerating the trajectories is not feasible.

Acknowledgments

We would like to thank Neil Burch, Johannes Heinrich, and Martin Schmid for feedback. Dustin Morrill was supported by The Alberta Machine Intelligence Institute (Amii) and Alberta Treasury Branch (ATB) during the course of this research.

Appendix A Proofs

A.1 Cyclical Perfect Information Games and Markov Games

Proof of Theorem 1.

The proof uses tools from the non-smooth analysis to properly handle gradients of a non-smooth function. We use the notion of generalized gradients defined in Clarke [1975]. The generalized gradient of a Lipschitz function is the convex hull of the limits of the form $\lim\nabla f(x+h_{i})$ where $h_{i}\rightarrow 0$. The only assumption we will require is that the parameters of our policy $\theta_{i}$ remains in a compact set $\Theta_{i}$ and that $v_{i,(\pi_{\theta_{i}},\pi_{-i})}$ is differentiable with respect to $\theta_{i}$ for all $\pi_{-i}$.

More precisely we use [Clarke, 1975, Theorem 2.1] to state our result. The theorem requires the function to be uniformly semi-continuous which is the case if the policy is differentiable since the dependence of $v_{i,(\pi_{\theta_{i}},\pi_{-i})}$ on $\pi_{-i}$ is polynomial. The function $v_{i,(\pi_{\theta_{i}},\pi_{-i})}$ is Lipschitz with respect to $(\theta_{i},\pi_{-i})$. The uniform continuity of $\nabla_{\theta_{i}}v_{i,(\pi_{\theta_{i}},\pi_{-i})}$ comes from the fact that $\Theta_{i}$ is compact.

Using [Clarke, 1975, Theorem 2.1], we have that $\partial\min_{\pi_{-i}}v_{i,(\pi_{\theta_{i}},\pi_{-i})}$ is the convex hull of $\{\nabla_{\theta_{i}}v_{i,\pi_{\theta_{i}},\beta}|\beta\in\textsc{BR}(\pi_{\theta_{i}}))\}$, so $\nabla_{\theta_{i}}v_{i,\pi_{\theta_{i}},\beta}\in\partial\min_{\pi_{-i}}v_{i,(\pi_{\theta_{i}},\pi_{-i})}$.

The proof follows by applying the policy gradient theorem Baxter and Bartlett [2001] to $\nabla_{\theta_{i}}v_{i,\pi_{\theta_{i}},\beta}$. ∎

Proof of Lemma 1.

In a two-player, zero-sum game, NashConv reduces to the sum of exploitabilities:

[TABLE]

so doing policy gradient in the worst case independently for all players locally minimizes the sum of exploitabilities and therefore NashConv. Formally we have222Usually one would have $\partial_{\bm{\theta}}(f_{1}+f_{2})\subset\partial_{\bm{\theta}}f_{1}+\partial_{\bm{\theta}}f_{2}$. But since in our case the functions are defined on two different sets of parameters, we have an equality.:

[TABLE]

∎

A.2 Imperfect Information Games

Before we prove the main proof (of Theorem 2), we start with some definitions, a previous theorem, and a supporting lemma.

Definition 1**.**

Recall $\Delta_{s}$ and $\Pi_{\ell_{2}}$ from Section 3.1. Define strong policy gradient policy iteration against specific opponent(s), SPGPI$({\bm{\pi}}_{-i})$, to be the process where player $i$ updates their policy using state-localized gradient ascent while all other players use ${\bm{\pi}}_{-i}$, according to Eq 5.

This is a form of strong policy gradient policy iteration (SPGPI) defined in [Srinivasan et al., 2018, Theorem 2] that separates the optimization for each player. Also notice that an iteration of TabularED($q$, $\ell_{2}$) is equivalent to $n$ simultaneous applications of SPGPI$(b_{-i}({\bm{\pi}}_{i}))$.

Definition 2**.**

Suppose all players use a sequence of joint policies $\{{\bm{\pi}}^{1},\cdots,{\bm{\pi}}^{T}\}$ over $T$ iterations. Define player $i$’s regret after $T$ iterations to be the difference in expected utility between the best possible policy in hindsight and the expected utility given the sequence of policies:

[TABLE]

Theorem 4**.**

*[*Srinivasan et al., 2018, Theorem 2] Suppose players play a finite game using joint policies $\{{\bm{\pi}}^{1},\cdots,{\bm{\pi}}^{T}\}$ over $T$ iterations. In a two-player zero-sum game, if $\forall s,a\in\mathcal{S}\times\mathcal{A}:\theta_{s,a}>0$ and $\alpha^{t}=t^{-\frac{1}{2}}$, then the regret of SPGPI$({\bm{\pi}}_{-i})$ after $T$ iterations is $R^{T}_{i}\leq\epsilon$, where $\epsilon=|\mathcal{S}_{i}|\left(\sqrt{T}+(\sqrt{T}-\frac{1}{2})|\mathcal{A}_{i}|(\Delta_{u_{i}})^{2}\right)+O(T)$, and $\Delta_{u}=\max_{z,z^{\prime}\in\mathcal{Z}}(u_{i}(z)-u_{i}(z^{\prime}))$.

Note that, despite the original application of policy gradients in self-play, it follows from the original proof that the statement about the regret incurred by player $i$ does not require a specific algorithm generate the opponents’ policies: it is only a function of the specific sequence of opponent policies. In particular, they could be best response policies, and so SPGPI$(b_{-i}({\bm{\pi}}_{i}))$ has the same regret guarantee.

The following lemma states an optimality bound of the best iterate under time-independent loss functions equal to the average regret. The best strategy in a no-regret sequence of strategies then approaches an equilibrium strategy over time without averaging and without probabilistic arguments.

Lemma 2**.**

Denote $[[T]]=\{1,2,\cdots,T\}$. For any sequence of $T$ iterates, $\{\boldsymbol{\theta}^{t}\in\Theta\}_{t\in[[T]]}$, from decision set $\Theta$, the regret of this sequence under loss, $\ell(\boldsymbol{\theta}):\Theta\rightarrow\Re$, is

[TABLE]

Then, the iterates with the lowest loss, $\hat{\boldsymbol{\theta}}=\operatornamewithlimits{argmin}_{t\in[[T]]}\ell(\boldsymbol{\theta}^{t})$, has an optimality gap bounded by the average regret:

[TABLE]

Proof.

Since $\ell$ is fixed (not varying with $t$),

[TABLE]

and dividing by $T$ yields the result. ∎

In finite games, we can replace the $\inf$ operation in Lemma 2 with $\min$ when the decision set is the set of all possible strategies, since this set is closed.

We now provide the proof of the main theorem.

Proof of Theorem 2.

The first part of the proof follows the logic of the CFR-BR proofs Johanson et al. [2012]. Unlike CFR-BR, we then use Lemma 2 to bound the quality of the best iterate.

SPGPI($b_{-i}(\pi_{i})$), has regret for player $i$ as described in Theorem 4. Define loss function, $\ell_{i}({\bm{\pi}}_{i})=-\min_{{\bm{\pi}}_{-i}}v_{i,({\bm{\pi}}_{i},{\bm{\pi}}_{-i})}$, as the negated worst-case value for player $i$, like that described by [Waugh and Bagnell, 2014, Theorem 4]. Then by Lemma 2 and Theorem 4 we have, for the best iterate:

[TABLE]

so $\delta_{i}({\bm{\pi}}^{*})\leq\frac{\epsilon}{T}+O(1)$, where $\delta_{i}({\bm{\pi}})$ is the exploitability defined in Section 2. The Nash equilibrium approximation bound is just the sum of the exploitabilities. ∎

The $O(1)$ term here comes from the $O(T)$ term in Theorem 4. When counterfactual values are used instead of $q$-values, the bound in Theorem 4 does not contain the $O(T)$ term and hence there is no $O(1)$ term. As a result Lemma 2 can be used to obtain Corollary 1.

Proof of Theorem 3.

This update rule is identical to that of generalized infinitesimal gradient ascent (GIGA) Zinkevich [2003] at each information state with best response counterfactual values. CFR-BR(GIGA) therefore performs the same updates and the two algorithms coincide. With step sizes $\alpha^{t}=t^{-\frac{1}{2}},0<t\leq T$, each local GIGA instance has regret after $T$ iterations upper bounded by $\sqrt{T}+(\sqrt{T}-\frac{1}{2})|\mathcal{A}_{i}|(\Delta_{u_{i}})^{2}$, where $\Delta_{u}=\max_{z,z^{\prime}\in\mathcal{Z}}(u_{i}(z)-u_{i}(z^{\prime}))$. Then, by the CFR Theorem Zinkevich et al. [2008], the regret is bounded by

[TABLE]

Specifically, the $O(T)$ term is missing since counterfactual values are used instead of $q$-values, and the bound is instead inherited from the CFR theorem. ∎

Appendix B Longer Descriptions of Experiment Domains

Kuhn poker

is a simplified poker game first proposed by Harold Kuhn Kuhn [1950]. Each player antes a single chip, and gets a single private card from a totally-ordered 3-card deck, e.g.$\{J,Q,K\}$. There is a single betting round limited to one raise of 1 chip, and two actions: pass (check/fold) or bet (raise/call). If a player folds, they lose their commitment (2 if the player made a bet, otherwise 1). If neither player folds, the player with the higher card wins the pot (2, 4, or 6 chips). The utility for each player is defined as the number of chips after playing minus the number of chips before playing.

Leduc poker

is significantly larger game with two rounds and a 6-card deck in two suits, e.g. {JS,QS,KS, JH,QH,KH}. Like Kuhn, each player initially antes a single chip to play and obtains a single private card and there are three actions: fold, call, raise. There is a fixed bet amount of 2 chips in the first round and 4 chips in the second round, and a limit of two raises per round. After the first round, a single public card is revealed. A pair is the best hand, otherwise hands are ordered by their high card (suit is irrelevant). Utilities are defined similarly to Kuhn poker.

Liar’s Dice(1,1)

is dice game where each player gets a single private die in $\{\epsdice{1},\epsdice{2},\cdots,\epsdice{6}\}$, rolled at the beginning of the game. The players then take turns bidding on the outcomes of both dice, i.e. with bids of the form $q$-$f$ referring to quantity and face, or calling “Liar”. The bids represent a claim that there are at least $q$ dice with face value $f$ among both players. The highest die value, $\epsdice{6}$, counts as a wild card matching any value. Calling “Liar” ends the game, then both players reveal their dice. If the last bid is not satisfied, then the player who called “Liar” wins. Otherwise, the other player wins. The winner receives +1 and loser -1.

Goofspiel

or the Game of Pure Strategy, is a bidding card game where players are trying to obtain the most points. shuffled and set face-down. Each turn, the top point card is revealed, and players simultaneously play a bid card; the point card is given to the highest bidder or discarded if the bids are equal. In this implementation, we use a fixed deck of decreasing points. In this paper, we use $K=4$ and an imperfect information variant where players are only told whether they have won or lost the bid, but not what the other player played.

Appendix C Connections and Differences Between Gradient Descent, Mirror Descent, Policy Gradient, and Hedge

There is a broad class of algorithms that attempt to make incremental progress on an optimization task by moving parameters in the direction of a gradient. This elementary idea is intuitive, requiring only basic knowledge of calculus and functions to understand in abstract. One way to more formally justify this procedure comes from the field of online convex optimization Zinkevich [2003]; Hazan [2015]; Shalev-Shwartz and others [2012]. The linearization trick Shalev-Shwartz and others [2012] reveals how simple parameter adjustments based on gradients can be used to optimize complicated non-linear functions. Perhaps the most well known learning rule is that of gradient descent: $\bm{x}\leftarrow\bm{x}-\alpha\nabla_{\bm{x}}f(\bm{x})$, where the goal is to minimize function $f$.

Often problems will include constraints on $\bm{x}$, such as the probability simplex constraint required of decision policies. One often convenient way to approach this problem is transform unconstrained parameters, $\bm{\theta}$, to the nearest point in the feasible set, $\bm{x}\doteq\Pi(\bm{\theta})$, with a transfer function, $\Pi$. This separation between the unconstrained and constrained space produces some ambiguity in the way optimization algorithms are adapted to handle constraints. Do we adjust the transformed parameters or the unconstrained parameters with the gradient? And do we take the gradient with respect to the transformed parameters or the unconstrained parameters?

Projected gradient descent (PGD) Zinkevich [2003] resolves these ambiguities by adjusting the transformed parameters with the gradient of the transformed parameters. For PGD, the unconstrained parameters are not saved, they are only produced temporarily before they can be projected into the feasible set, $\bm{x}\leftarrow\Pi(\bm{x}-\alpha\nabla_{\bm{x}}f(\bm{x}))$. Mirror descent (MD) Nemirovsky and Yudin [1983]; Beck and Teboulle [2003], broadly, makes adjustments exclusively in the unconstrained space, and transfers to the feasible set on-demand. However, like PGD, MD uses the gradient with respect to the transformed parameters. E.g. A MD-based update is $\bm{\theta}\leftarrow\bm{\theta}-\alpha\nabla_{\bm{x}}f(\bm{x})$, and transfer is done on-demand, $\bm{x}\doteq\Pi(\bm{\theta})$.

Further difficulties are encountered when function approximation is involved, that is, when $\bm{x}\doteq\Pi(g(\bm{\theta}))$, for an arbitrary function $g$. Now PGD’s approach of making adjustments in the decision space where $\bm{x}$ resides is untenable because the function parameters, $\bm{\theta}$, might reside in a very different space. E.g. $\bm{x}$ may be a complete strategy while $\bm{\theta}$ may be a vector of neural network parameters with many fewer dimensions. But the gradient with respect to the $\bm{x}$ is also in the decision space, so MD’s update cannot be done exactly either.

A simple fix is to apply the chain rule to find the gradient with respect to $\bm{\theta}$. This is the approach taken by policy gradient (PG) methods Williams [1992]; Sutton et al. [2000]; Sutton and Barto [2018] (the “all actions” versions rather than sample action versions). A consequence of this choice, however, is that PG updates in the tabular setting (when $g$ is the identity function) generally do not reproduce MD updates.

E.g. hedge, exponentially weighted experts, or entropic mirror descent Freund and Schapire [1997]; Beck and Teboulle [2003], is a celebrated algorithm for approximately solving games. It is a simple no-regret algorithm that achieves the optimal regret dependence on the number of actions, $\log\left|\mathcal{A}\right|$, and it can be used in the CFR and CFR-BR framework instead of the more conventional regret-matching to solve sequential imperfect information games. It is also an instance of MD, which we show here.

Hedge accumulates values associated with each action (e.g. counterfactual values or regrets) and transfers them into the probability simplex with the softmax function to generate a policy. Formally, given a sequence of values $[\bm{\upsilon}^{t}]_{t=1}^{T},\bm{\upsilon}^{t}\doteq[\upsilon_{a}^{t}]_{a\in\mathcal{A}}$ and temperature, $\tau>0$, hedge plays

[TABLE]

We now show how to recover this policy creation rule with MD.

Given a vector of bounded action values, $\bm{\upsilon}\in\Upsilon^{\left|\mathcal{A}\right|}\subseteq\mathds{R}^{\left|\mathcal{A}\right|},\max\Upsilon-\min\Upsilon\leq\Delta$, the expected value of policy $\bm{\pi}_{\text{MD}}$ interpreted as a probability distribution is just the weighted sum of values, $\bar{\upsilon}\doteq\sum_{a\in\mathcal{A}}\pi_{\text{MD}}(a)\upsilon_{a}$.

The gradient of the expected value of $\bm{\pi}_{\text{MD}}$’s value is then just the vector of action values, $\bm{\upsilon}$. MD accumulates the gradients on each round,

[TABLE]

where $\alpha>0$ is a step-size parameter. If $\bm{\theta}^{0}$ is zero, then the current parameters, $\bm{\theta}^{t}$, are simply the step-size weighted sum of the action values.

If $\bm{\pi}_{\text{MD}}^{t}$ on each round, $t\geq 0$ is chosen to be $\bm{\pi}_{\text{MD}}^{t}=\Pi_{\text{sm}}(\bm{\theta}^{t})$, then we can rewrite this policy in terms of the action values alone:

[TABLE]

which one can recognize as hedge with $\tau\doteq 1/\alpha$. This shows how hedge fits into the ED framework. When counterfactual values are used for action values, ED with MD gradient-updates and a softmax transfer at every information state is identical to CFR-BR with hedge at every information state.

In comparison, PG, using the same transfer and tabular parameterization, generates policies according to

[TABLE]

$\dfrac{\partial\pi(a^{\prime})}{\partial\theta_{a}}=\pi(a^{\prime})\left[\mathds{1}_{a^{\prime}=a}-\pi(a)\right]$ [Sutton and Barto, 2018, Section 2.8], so the update direction, $\langle\nabla_{\bm{\theta}}\bm{\pi},\bm{\upsilon}\rangle$, is actually the regret scaled by $\bm{\pi}$:

[TABLE]

Knowing this, we can write the $\bm{\pi}_{\text{PG}}^{t}$ in concrete terms:

[TABLE]

The fact that the PG parameters accumulate regret instead of action value is inconsequential because the difference between action values and regrets is a shift that is shared between each action, and the softmax function is shift-invariant. But there is a substantive difference in that updates are scaled by the current policy.

Appendix D Global Minimum Conditions

In this section we will suppose that the policy $\pi_{i}(s,a)=\theta_{s,a}$ under the simplex constraints $\forall s,a,\;\theta_{s,a}-\psi_{s,a}^{2}=0$ and $\forall s,\;\sum_{a}\theta_{s,a}=1$ (where $psi$ is a slack variable to enforce the inequality constrain $\forall s,a,\;\theta_{s,a}\geq 0$)

[TABLE]

The Lagrangian is:

[TABLE]

Knowing that for all $br_{-i}$ :

[TABLE]

The gradient of the Lagrangian with respect to $\theta,\psi,\lambda$ is:

[TABLE]

Suppose that there exists a best response $br_{-i}$ such that $\frac{\partial L(\theta,\psi,\lambda)}{\partial\theta_{s,a}}=\frac{\partial L(\theta,\psi,\lambda)}{\partial\lambda_{s}}=\frac{\partial L(\theta,\psi,\lambda)}{\partial\lambda_{s,a}}=\frac{\partial L(\theta,\psi,\lambda)}{\partial\psi_{s,a}}=0$ (i.e. if 0 is in the set of generalized gradients). Two cases can appear:

-If $\theta_{s,a}>0$ then $\lambda_{s,a}=0$ and then:

[TABLE]

-If $\theta_{s,a}=0$ then $\psi_{s,a}=0$ and then:

[TABLE]

Two cases (one stable and one unstable):

• •

$\lambda_{s,a}\leq 0$ then we have a stable fixed point,

• •

$\lambda_{s,a}>0$ is not stable as then we could increase the value by switching to that action.

We conclude by noticing that $\pi_{\theta_{i}}$ is greedy with respect to the value of the joint policy $(\pi_{\theta_{i}},br_{-i})$, thus $\pi_{\theta_{i}}$ is a best response to $br_{-i}$. Since both policies are best responses to each other, $(\pi_{\theta_{i}},br_{-i})$ is a Nash equilibrium. $\pi_{\theta_{i}}$ is also therefore unexploitable.

Appendix E Corrections to the Original Paper

We have modified this paper from its original version as a result of changes made to the theorem statements in Srinivasan et al. [2018]. In particular, the $O(T)$ term was added to statements of Thereoms 2 and 4. Claims of TabularED($q$, $\ell_{2}$)’s guaranteed convergence to equilibria were removed. The claim of convergence of TabularED($q^{c}$, $\ell_{2}$) was unaffected since it reduces to CFR-BR(GIGA). We have also modified the text to clarify the convergence properties.