Balancing Two-Player Stochastic Games with Soft Q-Learning

1 Introduction

Stochastic Games (SG) provide a natural extension of reinforcement learning [Sutton and Barto, 1998; Mnih et al., 2015; Busoniu et al., 2010; Peters et al., 2010] to multiple agents, where adapting strategies in presence of humans or other agents is necessary [Shapley, 1953; Littman, 1994; Littman, 2001].

Current frameworks for stochastic games assume perfectly rational agents - an assumption that is violated in a variety of real-world scenarios, e.g., human-robot interaction [Goodrich and Schultz, 2007], and pick-up and drop-off domains [Agussurja and Lau, 2012]. In the context of computer games, the main focus of this paper, such a problem of perfect rationality is even more amplified. Here, in fact, it is not desirable to design agents that seek optimal behaviour as this leads humans to become quickly uninterested when playing against adversarial agents that are impossible to defeat [Hunicke, 2005]. Hence, to design games with adaptable and balancing properties tailored to human-level performance, there is a need to extend state-of-the-art SG beyond optimality to allow for tuneable behaviour.

One method to produce tuneable behaviour in reinforcement learning is to introduce an adjustable Kullback-Leibler (KL) constraint between the agent's policy and a reference one. In particular, by increasingly strengthening this constraint we can obtain policies increasingly close to the reference policy, and vice versa. Bounding policy updates in such a manner has been previously introduced in literature under different names. Examples include KL control, relative entropy policy search [Peters et al., 2010], path integral control [Kappen, 2005; Braun et al., 2011], information-theoretic bounded rationality [Ortega and Braun, 2013], informationtheory of decisions and actions [Tishby and Polani, 2011; Rubin et al., 2012], and soft Q-learning [Fox et al., 2016; Haarnoja et al., 2017]. Targeted problems using these methods are also wide-spread, e.g., tackling the overestimation problem in tabular Q-learning [Fox et al., 2016] and in Deep Q-networks [Leibfried et al., 2017], accounting for model misspecification [Grau-Moya et al., 2016], introducing safe policy updates in robot learning [Schulman et al., 2015], and inducing risk-sensitive control [van den Broek et al., 2010].

Contributions: Though abundant in literature, previous works only consider single-agent problems and are not readily applicable to stochastic games, which consider more than one interacting entity. With game balancing as our motivation, we propose a novel formulation of SG where agents are subject to KL constraints. In particular, our formulation introduces two KL constraints, one for each agent, limiting the space of available policies, which, in turn, enables tuneable behaviour. We then introduce an online strategy that can be used for game-play balancing even in high-dimensional spaces through a neural network architecture.

In short, the contributions of this paper can be summarised as: (1) proving convergence of the two-player soft Q-learning to a fixed point through contractions; (2) generalising team and zero-sum games in a continuous fashion and showing a unique value; (3) demonstrating convergence to correct behaviour by tuning the KL constraints on a simplified gridworld scenario; (4) extending our method to handle highdimensional spaces; and (5) inferring opponent's Lagrange multiplier by maximum-likelihood, and demonstrating gamebalancing behaviour on the game of Pong.

2 Background

2.1 Reinforcement Learning

In reinforcement learning (RL) [Sutton and Barto, 1998] an agent interacts with an unknown environment to determine an optimal policy that maximises total expected return. These problems are formalised as Markov decision processes (MDPs). Formally, an MDP is defined as the tuple 〈S,A, T ,R, γ〉 where S is the state space, A the action space, and T : S × A × S → [0, 1] denotes the state transition density. Namely, when being in state st ∈ S and applying an action at ∈ A, the agent transitions to st+1 ∼ T (st+1|st, at). The reward function R : S×A → R quantifies the agent's performance and γ is the discount factor that trades off current and future rewards. The goal is to implement a policy that maximises total discounted rewards, i.e., π⋆ (a|s) = argmaxπ V π (s), where V π (s) = E[ ∑∞t=0 γ tR(st, at)].

2.2 Single Agent Soft Q-Learning

A way to constrain the behaviour of an agent is to modify the feasibility set of allowable policies. This can be achieved by introducing a constraint, such as a KL between two policy distributions, to the reinforcement learning objective. Such an approach has been already used within single agent reinforcement learning. For example, soft Q-learning has been used to reduce the overestimation problem of standard Qlearning [Fox et al., 2016] and for building flexible energybased policies in continuous domains [Haarnoja et al., 2017]. Most of these approaches modify the standard objective of reinforcement learning to

where C is the amount of bits (or nats if using the natural logarithm) measured by the KL divergence that the policy π is allowed to deviate from a reference policy ρ. The expectation operation is over state-action trajectories.

To solve the above constrained problem, one typically introduces a Lagrange multiplier, β, and rewrites an equivalent unconstrained problem

To derive an algorithm for solving the above, one comes to recognise that V ⋆ (s) also satisfies a recursion similar to that introduced by the Bellman equations [Puterman, 1994]. Additionally, the optimal policy can be written in closed form as

where Q⋆ (s, a) := R(s, a) + ∑s′∈S T (s′ |s, a)V ⋆ (s′ ), and s′ ∈ S. Notice that the above represents a generalisation of standard RL settings, where β → ∞ corresponds to a perfectly rational valuation (V ⋆ β→∞(s) = maxπ V π (s)), while for β → 0 we recover the valuation under ρ (V ⋆ β→0 (s) = V ρ (s)). Clearly, we can generate a continuum of policies between the reference and the perfectly rational policy that maximises the expected reward by tuning the choice of β as detailed in [Leibfried et al., 2017].

2.3 Two-Player Stochastic Games

In two-player stochastic games [Shapley, 1953; Littman, 1994], two agents, that we denote as the player and the opponent, are interacting in an environment. Each agent executes a policy that we write as πpl and πop. At some time step t, the player chooses an action apl t ∼ πpl (apl t |st ), while the opponent picks aop t ∼ πop (aop t |st ). Accordingly, the environment transitions to a successor state st+1 ∼ TG (st+1|st, apl t , aop t ), where TG denotes the joint transition model for the game. After transitioning to a new state, both agents receive a particular reward depending on the type of game considered. In team games, both the player and the opponent maximise the same reward function RG (st, apl t , aop t ). For zero-sum games, the player seeks to maximise RG, whereas the opponent seeks to find a minimum. We write the policy dependent value as V πplπop (s) := E[∑∞t=0 γ tRG (st, apl t , aop t )] where, in contrast to the one-player setting, the expectation is over state and joint-action trajectories.

In stochastic games it is common to assume perfect rationality for both agents i.e., in the case of a zero-sum game the player computes the optimal value of state s as V ⋆pl zs (s) = maxπpl minπop V πplπop (s), while the opponent as V ⋆op zs (s) = minπop maxπpl V πplπop (s). Similarly, in team games the optimal value for the player is V ⋆pl tg (s) = maxπpl maxπop V πplπop (s) and for the opponent V ⋆op tg (s) = maxπopp maxπpl V πplπop (s). Although it is straightforward to show that for team games V ⋆op tg (s) = V ⋆pl tg (s), an important classic result in game theory - the minimax theorem [Osborne and Rubinstein, 1994] - states that for zero-sum games V ⋆op zs (s) = V ⋆pl zs (s), i.e both team and zero sum games have a unique value.

Importantly, in complex games with large state-spaces the max and the min operations over all available policies are extremely difficult to compute. Humans and suboptimal agents seek to approximate these operations as best they can but never fully do so due to the lack of computational resources [Ortega and Stocker, 2016], approximations and introduced biases [Lieder et al., 2012]. This limits the applicability of SG when interacting with suboptimal entities, e.g., in computer games when competing against human players. We next provide the first extension, to the best of our knowledge, of soft Q-learning to SGs and show how our framework can be used within the context of balancing the game's difficulty.

3 Two-Player Soft Q-Learning

To enable soft Q-learning in two-player games we introduce two KL constraints that allow us to separately control the performance of both agents. In particular, we incorporate a constraint similar to (1) into the objective function for each agent and apply the method of Lagrange multipliers

where the expectation is over joint-action trajectories, 1 βpl log πpl(apl t |st) ρpl (apl t |st) is the information cost for the player (that turns into a KL divergence with the expectation operator), and 1 βop log πop(aop t |st) ρop(aop t |st) is the information cost for the opponent. The Lagrange multipliers βpl and βop are tuneable parameters that we can vary at will. The distributions ρpl(apl t |st) and ρop(aop t |st) are the arbitrary reference policies that we assume to be uniform 1 . Using the above, the player and the opponent compute optimal soft-value of a state s using

We define the extremum operator ext to correspond to a max in the case of positive βop and to a min in the case of negative βop.

It is clear that this novel formulation of the optimisation problems in Equations (3) generalise to cover both zero-sum and team games depending on the choice of βop. By fixing βpl → ∞ and setting βop → -∞ or βop → ∞ we recover, respectively, a zero-sum or a team game with perfectly rational agents. For βop → 0 we derive a game by which the opponent simply employs policy ρop. For finite values of βop, we obtain a continuum of opponents with bounded performance ranging from fully adversarial to fully collaborative including a random policy. It is important to note, as we will show later, that the analytical form of the optimal policies that solve (3) are independent of the extremum operator and only depend on the parameters βpl and βop.

3.1 Unique Value for Two-Player Soft Q-Learning

In this section we show that the equations in (3) are equivalent, V ⋆ pl (s) = V ⋆ op (s), for any βpl and βop, that is, our two player soft Q-learning exhibit a unique value.

We start by defining the free energy operator as

for an arbitrary free energy vector V. Then the Bellmanlike operators for both the player and the opponent can be

1 Please note considering other reference policies is left as an interesting direction for future work.

Proof Sketch: For proving our main results, summarised in Theorem 2, we commence by showing that the equations in (3) are equivalent. This is achieved by showing that the two operators in Equation (5) are in fact equivalent, see Lemma 1. Proving these operators to be contractions converging to a unique fixed point (see Theorem 1), we conclude that V ⋆ pl (s) = V ⋆ op (s).

Lemma 1. For any βpl ∈ R and βop ∈ R, and arbitrary free energy vector V, then BplV(s) = BopV(s).

Due to Lemma 1, we can define the generic operator BV(s) := BplV(s) = BopV(s). Then, for this generic operator, we can prove the following.

Theorem 1 (Contraction). For βop ∈ R and βpl ∈ R, the operator B is an L∞-norm contraction map ‖BV -B ¯ V‖∞ ≤ γ‖V - ¯ V‖∞, where V and ¯ V are two arbitrary free energy vectors and γ is the discount factor.

Note that our reward is policy dependent (in the information cost) and, therefore, Theorem 1 is not a direct consequence of known results [Littman and Szepesv´ari, 1996], which assume that these rewards are policy independent. Using the above and the Banach's fixed point theorem [Puterman, 1994], we obtain the following corollary.

Corollary 1 (Unique fixed point). The contraction mapping B exhibits a unique fixed-point V ⋆ such that BV ⋆ = V ⋆ .

Due to Lemma 1, Theorem 1 and Corollary 1, we arrive at the following.

Corollary 2. Two-player stochastic games with soft Qlearning have a unique value, i.e. V ⋆ pl (s) = V ⋆ op (s).

3.2 Bounded-Optimal Policies

Corollary 2 allows us to exploit the fact that there exists one unique value to generate the policies for both agents. With this in mind, we next design an algorithm (similar in spirit to standard Q-Learning) that acquires tuneable policies. We start by defining a state-action value function, in resemblance to the Q-function, as

For action selection, neither the player nor the opponent can directly use Q⋆ as it depends on the action of the other agent, which is unknown a priori. Instead, it can be shown that agents must first compute the certainty equivalent by marginalising Q⋆ as

With these definitions and using standard variational calculus, we obtain optimal policies for both the player and the opponent as 2

where Zpl(s) and Zop(s) are normalising functions which can be exactly computed when assuming small discrete action spaces.

Hence, V ⋆ (s) can be expressed in closed form by incorporating the optimal policies in Equation (3) giving

As summarised in Algorithm 1, we learn Q⋆ (s, apl , aop ) by applying the following recursion rule:

Here, α is the learning rate, k the learning step, and Vk(s′ ) is computed as in Equation (7) using the current Qk estimate.

Algorithm 1 Two-Player Soft Q-Learning

• 1: Given ρpl, ρop, βpl, βop, A, S and learning rate α
• 2: Q(s, apl , aop ) ← 0
• 3: while not converged do
• 4: Collect transition (st, apl t , aop t ,Rt, s′t ), where apl ∼ πpl, aop ∼ πop and Rt is the reward at time t.
• 5: Update Q according to Equation (8)
• 6: end while
• 7: return Q(s, apl , aop )

4 Real-World Considerations

Two restrictions limit the applicability of our algorithm to real-world scenarios. First, Algorithm 1 implicitly assumes the knowledge of the opponent's parameter βop. Obtaining βop in real-world settings can prove difficult. Second, our algorithm has been developed for low-dimensional state representations. Clearly, this restricts its applicability to highdimensional states that are typical to computer games.

To overcome these issues, we next develop an online maximum likelihood procedure to infer βop from data gathered through the interaction with the opponent, and then generalise Algorithm 1 to high-dimensional representations by proposing a deep learning architecture.

2 Note that, if we assume that the action space has low cardinality, Q⋆pl(s, apl ) and Q⋆op(s, aop ) can be computed exactly.

4.1 Estimating βop &Game-Balancing

Rather than assuming access to the opponents rationality parameter, we next devise a maximum likelihood estimate that allows the agent to infer (in an online fashion) about βop and consequently, about the real policy of the opponent (through Equation (6)).

Contrary to current SG techniques that attempt to approximate the opponent's policy directly, our method allows to reason about the opponent by only approximating a one dimensional parameter, i.e., βop in Equation (6) 3 .

Estimating βop: We frame the problem of estimating βop as a one of online maximum likelihood estimation. Namely, we assume that the player interacts in R rounds with the opponent. At each round, j, the player gathers a dataset of the form

tal number of sampled transitions during round j. Given D(j) , the agent estimates its knowledge of the opponent's model i.e., βop by solving the following problem 4

where π⋆ op (a(j),op i |s(j) i ) is defined in Equation (6). As rounds progress, the agent should learn to improve its estimate of βop. Such an improvement is quantified, in terms of regret 5 , in the following theorem for both a fixed and a timevarying opponent.

Theorem 2. After R rounds, the average static-regret for estimating βop vanishes as:

For a time-varying opponent, the dynamic regret bound dictates:

with Lj(·) denoting the negative of the log-likelihood and u⋆j = argminu Lj(u).

3 Please note that similar to the previous section we assume the opponent's reference policy ρop to be uniform. This, however, does not impose a strong restriction since having a uniform reference policy enables enough flexibility to model various degrees of the opponent's performances (see Section 5).

4 Please note that this problem can be easily solved using stochastic gradient descent.

5 Regret is a standard notion to quantify the performance of an online learning algorithm. Regret measures the performance of the agent with respect to an adversary that has access to all information upfront.

From the above theorem we conclude that against a fixedopponent our method guarantees correct approximation of βop. This is true since the average regret, O(√R)/R, vanishes as R → ∞. When it comes to a dynamic opponent, however, it is clear that our bound depends on how the value of the opponents multiplier parameter (in other words its policy) vary with in terms of rounds. In case these variations are bounded in number, we can still guarantee vanishing regrets. If not, the regret bound can grow arbitrarily large since ∑R-1 j=1 ||u⋆j+1 -u⋆j ||22 can introduce a factor R.

Game Balancing: Now that we have a way to learn Q⋆ and estimate βop simultaneously, we could balance the game using the estimate of βop to adjust the player's parameter βpl. A simple heuristic that proved successful in our experiments was to simply set βpl = |βop| +∆, where ∆ denotes an additional performance-level the player can achieve. Setting ∆ = 0 would correspond to agents with the same KL constraints, whereas setting ∆ > 0 would imply a stronger player with a softer KL constraint (see Section 5.2).

4.2 Deep Two-Player Soft Q-Learning

When tackling higher dimensional problems, one has to rely on function approximators to estimate the Q-function, or in our case, the function Q(s, apl , aop ). We borrow two ideas from deep Q-networks [Mnih et al., 2015] that allow us to stabilise learning with high-dimensional representations for our SG setting. First, we use the notion of a replay memory to store the following transitions (s, apl , aop , s′ ,RG(·)) and, second, we use a target network denoted by Q(s, apl , aop ; θi ) to handle non-stationarity of the objective. We learn Q(s, apl , aop ; θi), by using a neural network that receives s as input and outputs a matrix of Q-values for each combination of the agents' actions. The loss function that we seek to minimise is L(θi) = E[ (RG (s, apl , aop ) + γV(s; θi ) -Q(s, apl , aop ; θi))2 ]

with the expectation taken over the distribution of transitions sampled from the replay memory, and V(s; θi ) computed as in Equation (7). Clearly, the above optimisation problem is similar to standard DQNs with the difference that error is measured between soft Q-values.

5 Experiments

We consider two cases in our experiments. The first assumes a low-dimensional setting, while the second targets the highdimensional game of Pong. In both cases we consider full and no control of the opponent. Full control will allow us to validate our intuitions of tuneable behaviour, while the second sheds-the-light on the game balancing capabilities of Section 4.

5.1 Low-dimensional Experiments

The Setup: We validate Algorithm 1 on a 5 × 6 grid-world, where we consider two agents interacting. Each can choose an action from A = {left, right, up, down, pick-up}. The first four actions are primitive movements, while the last corresponds to picking-up an object when possible. The reward of the first player is set to -0.02 for any movement and to +1 for picking up the object located in cell (2,6).

The setting described in this paper allows for a range of games that can be continuously varied between cooperative and defective games depending on the choice of βop - a setting not allowed by any of the current techniques to stochastic games. In other words, the goal of the opponent, now, depends on the choice of βop. Namely, for positive values of βop, the opponent is collaborative, whereas for negative βop it is adversarial. βop values in between correspond to tuneable performance varying between the above two extremes.

We demonstrate adversarial behaviour by allowing agents to block each other either when trying to reach the same cell, or when attempting to transition to a cell previously occupied by the other agent. In such cases the respective agent remains in its current position. Given the determinism of the environment, a perfectly rational adversarial opponent can always impede the player to reach the goal. However, due to the KL constraints the opponent's policy becomes "less" aggressive, allowing the player to exploit the opponent's mistakes and arrive to the goal. For all experiments we used a high learning rate of α = 0.56 .

Tuning the Player's Performance: To validate tuneablity, we assess the performance of the player when reaching convergence while varying βpl and βop. In the first set of experiments, we fixed βpl = 20 and varied βop = {-20,-15,-10,-5, 0, 5, 10, 15, 20}. We expect that the player obtains high reward for collaborative opponents (βop > 0) or highly sub-optimal adversarial opponents (βop ≈ 0), and low rewards for strong adversarial opponents

6 A deterministic environment transitions allows for a large learning rate.

(βop ≪ 0). Indeed, the results shown in Figure 1(a) confirm these intuitions.

For a broader spectrum of analysis, we lower βpl from 20 to 5 and re-run the same experiments. Results in Figure 1(b) reaffirm the previous conclusions. Here, however, the player attains slightly lower rewards as βpl is decremented. Finally, in Figure 1(c) we plot the reward attained after convergence for a broad range of parameter values. We clearly see the effect of the modulation in both parameters on the resultant reward. The best reward is achieved when both parameters have positive high values, and the least reward for the lowest values.

Estimating βop: The goal of these experiments is to evaluate the correctness of our maximum likelihood estimate (Section 4.1) of βop. To conduct these experiments, we fixed βpl = 10 and generated data with β⋆ op = 5 and β⋆ op = -10 that are unknown to the player. At each interaction with the environment, we updated V(·) according to Algorithm 1 and βop using a gradient step in the maximum likelihood objective. Results reported in Figure 2, clearly demonstrate that our extension to estimate βop is successful 7 .

5.2 High-dimensional Experiments

We repeat the experiments above but now considering our deep learning architecture of Section 4.2 on the game of Pong.

The Setup: We use the game Pong from the Roboschool package 8 . The state space is 13-dimensional i.e., x-y positions and x-y- velocities for both agents and the ball, and an additional dimension for time. We modified the action space to consist of |A| = 9 actions where the set corresponds to A = {left, stay, right} × {up, stay, down}. We also modified the reward function to make it compatible with zerosum games in such a way that if the player scores, the reward RG is set to +1, whereas if the opponent scores, to -1. The networks that represent soft Q-values, Q(s, apl , aop ), are multilayer perceptrons composed of two hidden layers, each with 100 units, and an a matrix output layer composed of |A×A| = 81 units (9 × 9 actions). Here, each unit denotes a particular combination of apl ∈ A and aop ∈ A. After each hidden layer, we introduce a ReLU non-linearity. We used a learning rate of 10-4 , the ADAM optimizer, a batch size of 32, and updated the target every 30000 training steps.

Tuning the Player's Performance: In this experiment, we demonstrate successful tuneable performance. Figure 3 shows that for a highly adversarial opponent (i.e., βop = -50) the player (βpl = 20) acquired negative rewards, whereas for a weak opponent or even collaborative, the player obtained high reward. Game-play videos can be found at https://sites.google.com/site/submission3591/.

Estimating βop and game balancing: Finally, we assess the performance of the maximum likelihood estimator applied to game balancing using neural networks. We pretrained a policy for the opponent with parameters β⋆ pl = 50.0 and βop = -20.0, thus the player being stronger than the opponent (see blue line in Figure 4). In Figure 4, we demonstrate game balancing using Section 4.1. In particular, we are able to vary the player's performance by adapting (online) βpl. For instance, if we set βpl close to βop we observe that the player is as strong as the opponent attaining 0 reward, see green line.

7 In the case where the opponent would have an arbitrary policy πa then βopwould converge to a value that attempts to make πop,βop as close as possible to πa.

8 https://github.com/openai/roboschool

6 Conclusion

We extended two-player stochastic games to agents with KL constraints. We evaluated our method theoretically and empirically in both small and high-dimensional state spaces. The most interesting direction for future work is to scale our method to a large number of interacting agents by extending the approach in [Mguni et al., 2018].