ON SOLVING MINIMAX OPTIMIZATION LOCALLY: A FOLLOW-THE-RIDGE APPROACH
Year: 2020

Abstract:
Many tasks in modern machine learning can be formulated as finding equilibria in sequential games. In particular, two-player zero-sum sequential games, also known as minimax optimization, have received growing interest. It is tempting to apply gradient descent to solve minimax optimization given its popularity and success in supervised learning. However, it has been noted that naive application of gradient descent fails to find some local minimax and can converge to nonlocal-minimax points. In this paper, we propose Follow-the-Ridge (FR), a novel algorithm that provably converges to and only converges to local minimax. We show theoretically that the algorithm addresses the notorious rotational behaviour of gradient dynamics, and is compatible with preconditioning and positive momentum. Empirically, FR solves toy minimax problems and improves the convergence of GAN training compared to the recent minimax optimization algorithms1.

text: 1 INTRODUCTION
We consider differentiable sequential games with two players: a leader who can commit to an action, and a follower who responds after observing the leader’s action. Particularly, we focus on the zero-sum case of this problem which is also known as minimax optimization, i.e.,
min x∈Rn max y∈Rm f(x,y).
Unlike simultaneous games, many practical machine learning algorithms, including generative adversarial networks (GANs) (Goodfellow et al., 2014; Arjovsky et al., 2017), adversarial training (Madry et al., 2018) and primal-dual reinforcement learning (Du et al., 2017; Dai et al., 2018), explicitly specify the order of moves between players and the order of which player acts first is crucial for the problem. Therefore, the classical notion of local Nash equilibrium from simultaneous games may not be a proper definition of local optima for sequential games since mini-
max is in general not equal to maximin. Instead, we consider the notion of local minimax (Jin et al., 2019) which takes into account the sequential structure of minimax optimization.
The vanilla algorithm for solving sequential minimax optimization is gradient descent-ascent (GDA), where both players take a gradient update simultaneously. However, GDA is known to suffer from two drawbacks. First, it has undesirable convergence properties: it fails to converge to some local minimax and can converge to fixed points that are not local minimax (Jin et al., 2019; Daskalakis and Panageas, 2018). Second, GDA exhibits strong rotation around fixed points, which requires using very small learning rates (Mescheder et al., 2017; Balduzzi et al., 2018) to converge.
In this paper, we propose Follow-the-Ridge (FR), an algorithm for minimax optimization that addresses both issues. Specifically, we elucidate the cause of undesirable convergence of GDA – the
∗These two authors contributed equally. 1Our code is made public at: https://github.com/gd-zhang/Follow-the-Ridge
leader whose gradient step takes the system away from the ridge. By adding a correction term to the follower, we explicitly cancel out negative effects of the leader’s update. Intuitively, the combination of the leader’s update and the correction term is parallel to the ridge in the landscape (see Fig. 1), hence the name Follow-the-Ridge. Overall, our contributions are the following: • We propose a novel algorithm for minimax optimization which has exact local convergence to
local minimax points. Previously, this property was only known to be satisfied when the leader moves infinitely slower than the follower in gradient descent-ascent (Jin et al., 2019). • We show theoretically and empirically that FR addresses the notorious rotational behaviour of
gradient dynamics around fixed points (Balduzzi et al., 2018) and thus allows a much larger learning rate compared to GDA. • We prove that our algorithm is compatible with standard acceleration techniques such as
preconditioning and positive momentum, which can speed up convergence significantly. • We further show that our algorithm also applies to general-sum Stackelberg games (Fiez et al.,
2019; Zeuthen, 1935) with similar theoretical guarantees. • Finally, we demonstrate empirically our algorithm improves the convergence performance in
both toy minimax problems and GAN training compared to existing methods.

heading: 2 PRELIMINARIES

heading: 2.1 MINIMAX OPTIMIZATION
text: We consider sequential games with two players where one player is deemed the leader and the other the follower. We denote leader’s action by x ∈ Rn, and the follower’s action by y ∈ Rm. The leader aims at minimizing the cost function f(x,y) while the follower aims at maximizing f(x,y). The only assumption we make on the cost function is the following. Assumption 1. f is twice differentiable everywhere, and thrice differentiable at critical points. ∇2yyf is invertible (i.e., non-singular).
The global solution to the sequential game minx maxy f(x,y) is an action pair (x∗,y∗), such that y∗ is the global optimal response to x∗ for the follower, and that x∗ is the global optimal action for the leader assuming the follower always play the global optimal response. We call this global solution the global minimax. However, finding this global minimax is often intractable; therefore, we follow Jin et al. (2019) and take local minimax as the local surrogate. Definition 1 (local minimax). (x∗,y∗) is a local minimax for f(x,y) if (1) y∗ is a local maximum of f(x∗, ·); (2) x∗ is a local minimum of φ(x) := f(x, r(x)), where r(x) is the implicit function defined by ∇yf(x,y) = 0 in a neighborhood of x∗ with r(x∗) = y∗.
In the definition above, the implicit function r(·) : Rn → Rm is a local best response for the follower, and is a ridge in the landscape of f(x,y). Local minimaxity captures an equilibrium in a two-player sequential game if both players are only allowed to change their strategies locally. For notational convenience, we define
∇f(x,y) = [∇xf,∇yf ]> , ∇2f(x,y) = [ Hxx Hxy Hyx Hyy ] .
In principle, local minimax can be characterized in terms of the following first-order and second-order conditions, which were established in Jin et al. (2019). Proposition 1 (First-order Condition). Any local minimax (x∗,y∗) satisfies∇f(x∗,y∗) = 0. Proposition 2 (Second-order Necessary Condition). Any local minimax (x∗,y∗) satisfies Hyy 4 0 and Hxx −HxyH−1yyHyx < 0. Proposition 3 (Second-order Sufficient Condition). Any stationary point (x∗,y∗) satisfying Hyy ≺ 0 and Hxx −HxyH−1yyHyx 0 is a local minimax.
The concept of global/local minimax is different from Nash equilibrium and local Nash, which are the equilibrium concepts typically studied for simultaneous games (see Nash et al. (1950); Ratliff et al. (2016) for more details). In particular, we note that the concept of Nash equilibrium or local Nash does not reflect the order between the min-player and the max-player and may not exist even
for simple functions (Jin et al., 2019). In general, the set of local minimax is a superset of local Nash. Under some mild assumptions, local minimax points are guaranteed to exist (Jin et al., 2019). However, the set of stable fixed points of GDA, roughly speaking the set of points that GDA locally converges to, is a different superset of local Nash (Jin et al., 2019). The relation between the three sets of points is illustrated in Fig. 2.

heading: 2.2 STABILITY OF DISCRETE DYNAMICAL SYSTEMS
text: Gradient-based methods can reliably find local stable fixed points – local minima in single-objective optimization. Here, we generalize the concept of stability to games by taking game dynamics as a discrete dynamical system. An iteration of the form zt+1 = w(zt) can be viewed as a discrete dynamical system, where in our case w : Rn+m → Rn+m.
If w(z) = z, then z is called a fixed point. We study the stability of fixed points as a proxy to local convergence of game dynamics.
Definition 2. Let J denote the Jacobian of w at a fixed point z. If it has spectral radius ρ(J) ≤ 1, then we call z a stable fixed point. If ρ(J) < 1, then we call z a strictly stable fixed point.
It is known that strict stability implies local convergence (e.g., see Galor (2007)). In other words, if z is a strictly stable fixed point, there exists a neighborhood U of z such that when initialized in U , the iteration steps always converge to z.

heading: 3 UNDESIRABLE BEHAVIOURS OF GDA
text: In this section, we discuss the undesirable behaviours of GDA in more detail. Recall that the update rule of GDA is given by
xt+1 ← xt − η∇xf, yt+1 ← yt + η∇yf,
(1)
where we assume the same learning rate for both the leader and the follower for simplicity2. As illustrated in Fig. 2, the set of stable fixed points of GDA can include points that are not local minimax and, perhaps even worse, some local minimax are not necessarily stable fixed points of GDA. Here, we first give an example that a stable fixed point of GDA is not a local minimax. Consider minx maxy f(x, y) = 3x
2 + y2 + 4xy; the only stationary point of this problem is (0, 0) and the Jacobian of GDA at this point is
J = I− η [
6 4 −4 −2
] .
It is easy to see that the eigenvalues of J are e1 = e2 = 1− 2η. Therefore, by Definition 2, (0, 0) is a strictly stable fixed point of GDA. However, one can show that Hyy = 2 > 0 which doesn’t satisfy the second-order necessary condition of local minimax.
Similarly, one can easily find examples in which a local minimax is not in the set of stable fixed points of GDA, e.g., minx∈R maxy∈R f(x, y) = −3x2 − y2 + 4xy (see Fig. 1). In this example, the two Jacobian eigenvalues are both greater than 1 no matter how small the learning rate is. In other words, GDA fails to converge to (0, 0) for almost all initializations (Daskalakis and Panageas, 2018).
As we will discuss in the next section, the main culprit of the undesirable behaviours of GDA is the leader whose gradient update −η∇xf pushes the whole system away from the ridge or attracts the system to non-local-minimax points. By contrast, the follower’s step η∇yf can pull the system closer to the ridge (see Fig. 1) or push it away from bad fixed points. To guarantee convergence to local minimax (or avoid bad fixed points), we have to use a very small learning rate for the leader (Jin et al., 2019; Fiez et al., 2019) so that the η∇yf term dominates. In the next section, we offer an alternative approach which explicitly cancels out undesirable effects of −η∇xf , thereby allowing us to use larger learning rates for the leader.
2In general, the learning rates of two players can be different. Since our arguments apply to general setting as long as the ratio ηx/ηy is a positive constant, so we assume the same learning rate for convenience.

heading: 4 FOLLOW THE RIDGE
text: Despite its popularity, GDA has the tendency to drift away from the ridge or the implicit function, and can, therefore, fail to converge with any constant learning rate. To address these problems, we propose a novel algorithm for minimax optimization, which we term Follow-the-Ridge (FR). The algorithm modifies gradient descent-ascent by applying an asymmetric preconditioner. The update rule is described in Algorithm. 1.
Algorithm 1 Follow-the-Ridge (FR). Differences from gradient descent-ascent are shown in blue. Require: Learning rate ηx and ηy; number of iterations T .
1: for t = 1, ..., T do 2: xt+1 ← xt − ηx∇xf(xt,yt) . gradient descent 3: yt+1 ← yt + ηy∇yf(xt,yt) + ηxH−1yyHyx∇xf(xt,yt) . modified gradient ascent
The main intuition behind FR is the following. Suppose that yt is a local maximum of f(xt, ·). Let r(x) be the implicit function defined by∇yf(x,y) = 0 around (xt,yt), i.e., a ridge in the landscape of f(x,y). By definition, a local minimax has to lie on a ridge; hence, it is intuitive to follow the ridge during learning. However, if (xt,yt) is on the ridge, then ∇yf(xt,yt) = 0, and one step of gradient descent-ascent will take (xt,yt) to (xt− ηx∇xf,yt), which is off the ridge. In other words, gradient descent-ascent tends to drift away from the ridge. The correction term we introduce is ∇xr(x) (−ηx∇xf(xt,yt)) = ηxH−1yyHyx∇xf. It would bring yt to yt + ∇xr(x)(xt+1 − xt) ≈ r(xt+1), thereby encouraging both players to stay along the ridge. When (xt,yt) is not on a ridge yet, we expect the −ηx∇xf term and the ηxH −1 yyHyx∇xf term to move parallel to the ridge, while the ηy∇yf term brings (xt,yt) closer to the ridge (see Fig. 1). Our main theoretical result is the following theorem, which suggests that FR locally converges and only converges to local minimax. Theorem 1 (Exact local convergence). With a suitable learning rate, all strictly stable fixed points of FR are local minimax, and all local minimax points are stable fixed points of FR.
The proof is mainly based on the following observation. The Jacobian of FR dynamics at a fixed point (x∗,y∗) is (c := ηy/ηx)
J = I− ηx [
I −H−1yyHyx I ] [ Hxx Hxy −cHyx −cHyy ] ,
where the Hessians are evaluated at (x∗,y∗). J is similar to
M =
[ I
H−1yyHyx I
] J [ I
−H−1yyHyx I
] = I− ηx [ Hxx −HxyH−1yyHyx Hxy
−cHyy
] .
Therefore, the eigenvalues of J are those of I + ηyHyy and those of I− ηx(Hxx −HxyH−1yyHyx). As shown in second-order necessary condition 2, (x∗,y∗) being a local minimax implies Hyy 4 0 and Hxx −HxyH−1yyHyx < 0; one can then show that the spectral radius of the Jacobian satisfies ρ(J) ≤ 1; hence (x∗,y∗) is a stable fixed point by Definition 2. On the other hand, when ρ(J) < 1, by the sufficient condition in Proposition 3, (x∗,y∗) must be a local minimax. Remark 1 (All eigenvalues are real). We notice that all eigenvalues of J, the Jacobian of FR, are real since both Hyy and Hxx −HxyH−1yyHyx are symmetric matrices. As noted by Mescheder et al. (2017); Gidel et al. (2019); Balduzzi et al. (2018), the rotational behaviour (instability) of GDA is caused by eigenvalues with large imaginary part. Therefore, FR addresses the strong rotation problem around fixed points as all eigenvalues are real.

heading: 4.1 ACCELERATING CONVERGENCE WITH PRECONDITIONING AND MOMENTUM
text: We now discuss several extension of FR that preserves the theoretical guarantees.
Preconditioning: To speed up the convergence, it is often desirable to apply a preconditioner on the gradients that compensates for the curvature. For FR, the preconditioned variant is given by[
xt+1 yt+1 ] ← [ xt yt ] − [ I −H−1yyHyx I ] [ ηxP1∇xf −ηyP2∇yf ] (2)
We can show that with any constant positive definite preconditioners P1 and P2, the local convergence behavior of Algorithm 1 remains exact. We note that preconditioning is crucial for successfully training GANs (see Fig. 9) and RMSprop/Adam has been exclusively used in GAN training.
Momentum: Another important technique in optimization is momentum, which speeds up convergence significantly both in theory and in practice (Polyak, 1964; Sutskever et al., 2013). We show that momentum can be incorporated into FR (here, we include momentum outside the correction term which is equivalent to applying momentum to the gradient directly for simplicity. We give a detailed discussion in Appendix D.4), which gives the following update rule:[
xt+1 yt+1 ] ← [ xt yt ] − [ I −H−1yyHyx I ] [ ηx∇xf −ηy∇yf ] + γ [ xt − xt−1 yt − yt−1 ] . (3)
Because all of the Jacobian eigenvalues are real, we can show that momentum speeds up local convergence in a similar way it speeds up single objective minimization.
Theorem 2. For local minimax (x∗,y∗), let α = min { λmin(−Hyy), λmin(Hxx −HxyH−1yyHyx) } ,
β = ρ ( ∇2f(x∗,y∗) ) , κ := β/α. Then FR converges asymptotically to (x∗,y∗) with a rate Ω(κ−2);
FR with a momentum parameter of γ = 1−Θ ( κ−1 ) converges asymptotically with a rate Ω(κ−1).3
Experiments of the speedup of momentum are provided in Appendix E.2. This is in contrast to gradient descent-ascent, whose complex Jacobian eigenvalues prevent the use of positive momentum. Instead, negative momentum may be more preferable (Gidel et al., 2019), which does not achieve the same level of acceleration.

heading: 4.2 GENERAL STACKELBERG GAMES
text: Algorithm 2 Follow-the-Ridge (FR) for general-sum Stackelberg games. Require: Learning rate ηx and ηy; number of iterations T .
1: for t = 1, ..., T do 2: xt+1 ← xt − ηxDxf(xt,yt) . total derivative Dxf = ∇xf −∇2xyg(∇2yyg)
−1∇yf 3: yt+1 ← yt − ηy∇yg(xt,yt) + ηx(∇2yyg) −1∇2yxgDxf(xt,yt)
Here, we further extend FR to general sequential games, also known as Stackelberg games. The leader commits to an action x, while the follower plays y in response. The leader aims to minimize its cost f(x,y), while the follower aims at minimizing g(x,y). For Stackelberg games, the notion of equilibrium is captured by Stackelberg equilibrium, which is essentially the solution to the following optimization problem:
min x∈Rn
{ f(x,y)|y ∈ arg min
y∈Rm g(x,y)
} .
It can be seen that minimax optimization is the special case when g = −f . Similarly, one can define local Stackelberg equilibrium as a generalization of local minimax in general-sum games (Fiez et al., 2019). Stackelberg game has wide applications in machine learning. To name a few, both multi-agent reinforcement learning (Littman, 1994) and hyperparameter optimization (Maclaurin et al., 2015) can be formulated as finding Stackelberg equilibria.
For general-sum games, naive gradient dynamics, i.e., both players taking gradient updates with their own cost functions, is no longer a reasonable algorithm, as local Stackelberg equilibria in general may not be stationary points. Instead, the leader should try to use the total derivative of f(x, r(x)), where r(x) is a local best response for the follower. Thus the counterpart of gradient descent-ascent in general-sum games is actually gradient dynamics with best-response gradient (Fiez et al., 2019):
xt+1 ← xt − η [ ∇xf −∇2xyg ( ∇2yyg )−1∇yf] (xt,yt), yt+1 ← yt − η∇yg(xt,yt).
(4)
3By a rate a, we mean that one iteration shortens the distance toward the fixed point by a factor of (1− a); hence the larger the better.
FR can be adapted to general-sum games by adding the same correction term to the follower. The combined update rule is given in Algorithm 2. Similarly, we show that FR for Stackelberg games locally converges exactly to local Stackelberg equilibria (see Appendix C.2 for rigorous proof.)

heading: 5 RELATED WORK
text: As a special case of Stackelberg games (Ratliff et al., 2016) in the zero-sum setting, minimax optimization concerns the problem of solving minx∈X maxy∈Y f(x,y). The problem has received wide attention due to its extensive applications in modern machine learning, in settings such as generative adversarial networks (GANs), adversarial training. The vast majority of this line of research focus on convex-concave setting (Kinderlehrer and Stampacchia, 1980; Nemirovski and Yudin, 1978; Nemirovski, 2004; Mokhtari et al., 2019b;a). Beyond the convex-concave setting, Rafique et al. (2018); Lu et al. (2019); Lin et al. (2019); Nouiehed et al. (2019) consider nonconvexconcave problems, i.e., where f is nonconvex in x but concave in y. In general, there is no hope to find global optimum efficiently in nonconvex-concave setting.
More recently, nonconvex-nonconcave problem has gained more attention due to its generality. Particularly, there are several lines of work analyzing the dynamics of gradient descent-ascent (GDA) in nonconvex-nonconcave setting (such as GAN training). Though simple and intuitive, GDA has been shown to have undersirable convergence properties (Adolphs et al., 2019; Daskalakis and Panageas, 2018; Mazumdar et al., 2019; Jin et al., 2019) and exhibit strong rotation around fixed points (Mescheder et al., 2017; Balduzzi et al., 2018). To overcome this rotation behaviour of GDA, various modifications have been proposed, including averaging (Yazıcı et al., 2019), negative momentum (Gidel et al., 2019), extragradient (EG) (Korpelevich, 1976; Mertikopoulos et al., 2019), optimistic mirror descent (OGDA) (Daskalakis et al., 2018), consensus optimization (CO) (Mescheder et al., 2017) and symplectic gradient (SGA) (Balduzzi et al., 2018; Gemp and Mahadevan, 2018). However, we note that all these algorithms discard the underlying sequential structure of minimax optimization and adopt a simultaneous game formulation. In this work, we hold that GAN training is better viewed as a sequential game rather than a simultaneous game. The former is more consistent with the divergence minimization interpretation of GANs; there is also some empirical evidence showing that well-performing GAN generators are closer to a saddle-point instead of a local minimum (Berard et al., 2019), which suggests that local Nash, the typical solution concept for simultaneous games, may not be the most appropriate one for GANs.
To the best of our knowledge, the only two methods that can (and only) converge to local minimax are two time-scale GDA (Jin et al., 2019) and gradient dynamics with best response gradient (Fiez et al., 2019). In two time-scale GDA, the leader moves infinitely slower than the follower, which may cause slow convergence due to infinitely small learning rates. The dynamics in Fiez et al. (2019) is proposed for general-sum games. However, their main result for general-sum games require stronger assumptions and even in that case, the dynamics can converge to non-local-Stackelberg points in general-sum games. In contrast, in general-sum games, FR will not converge to non-local-Stackelberg points. Besides, Adolphs et al. (2019); Mazumdar et al. (2019) attempt to solve the undesirable convergence issue of GDA by exploiting curvature information, but they focus on simultaneous game on finding local Nash and it is unclear how to extend their algorithm to sequential games.
For GAN training, there is a rich literature on different strategies to make the GAN-game welldefined, e.g., by adding instance noise (Salimans et al., 2016), by using different objectives (Nowozin et al., 2016; Gulrajani et al., 2017; Arjovsky et al., 2017; Mao et al., 2017) or by tweaking the architectures (Radford et al., 2015; Brock et al., 2019). While these strategies try to make the overall optimization problem easily, our work deals with a specific optimization problem and convergence issues arise in theory and in practice; hence our algorithm is orthogonal to these work.

heading: 6 EXPERIMENTS
text: In this section, we investigate whether the theoretical guarantees of FR carry over to practical problems. Particularly, our experiments have three main aims: (1) to test if FR converges and only converges to local minimax, (2) to test the effectiveness of FR in training GANs with saturating loss, (3) to test whether FR addresses the notorious rotation problem in GAN training.

heading: 6.1 LOW DIMENSIONAL TOY EXAMPLES
text: To verify our claim on exact local convergence, we first compare FR with gradient descent-ascent (GDA), optimistic mirror descent (OGDA) (Daskalakis et al., 2018), extragradient (EG) (Korpelevich, 1976), symplectic gradient adjustment (SGA) (Balduzzi et al., 2018) and consensus optimization (CO) (Mescheder et al., 2017) on three simple low dimensional problems:
g1(x, y) = −3x2 − y2 + 4xy g2(x, y) = 3x 2 + y2 + 4xy
g3(x, y) = ( 4x2 − (y − 3x+ 0.05x3)2 − 0.1y4 ) e−0.01(x 2+y2).
Here g1 and g2 are two-dimensional quadratic problems, which are arguably the simplest nontrivial problems. g3 is a sixth-order polynomial scaled by an exponential, which has a relatively complicated landscape compared to g1 and g2.
It can be seen that when running in g1, where (0, 0) is a local (and in fact global) minimax, only FR, SGA and CO converge to it; all other method diverges (the trajectories of OGDA and EG almost overlap). The main reason behind the divergence of GDA is that gradient of leader pushes the system away from the local minimax when it is a local maximum for the leader. In g2, where (0, 0) is not a local minimax, all algorithms except for FR converges to this undesired stationary point4. In this case, the leader is still to blame for the undesirable convergence of GDA (and other variants) since it gets trapped by the gradient pointing to the origin. In g3, FR can converge to (0, 0), which is a local minimax, while all other methods apparently enter limit cycles around (0, 0). The experiments suggest that even on extremely simple instances, existing algorithms can either fail to converge to a desirable fixed point or converge to bad fixed points, whereas FR always exhibits desirable behaviors.

heading: 6.2 GENERATIVE ADVERSARIAL NETWORKS
text: One particularly promising application of minimax optimization algorithms is training generative adversarial networks (GANs). To recover the divergence minimization objective (e.g., JensenShannon divergence in standard GANs), we have to model the adversarial game as a sequential game. According to the formulation, the generator is the leader who commits to an action first, while the discriminator is the follower that helps the generator to learn the target data distribution.

heading: 6.2.1 MIXTURE OF GAUSSIANS
text: We first evaluate 4 different algorithms (GDA, EG, CO and FR) on mixture of Gaussian problems with the original saturating loss. To satisfy the non-singular Hessian assumption, we add L2 regularization (0.0002) to the discriminator. For both generator and discriminator, we use 2-hidden-layers MLP with 64 hidden units each layer where tanh activations is used. By default, RMSprop (Tieleman and Hinton, 2012) is used in all our experiments while the learning rate is tuned for GDA. As our FR involves the computation of Hessian inverses which is computational prohibitive, we instead use conjugate
4Note that it is a local minimum for the follower.
gradient (Martens, 2010; Nocedal and Wright, 2006) to solve the linear system in the inner loop. To be specific, instead of solving Hyyz = Hyx∇xf directly, we solve H2yyz = HyyHyx∇xf to ensure that the problem is well-posed since H2yy is always positive semidefinite. For all experimental details, we refer readers to Appendix D.2.
As shown in Fig. 4, GDA suffers from the “missing mode” problem and both discriminator and generator fail to converge as confirmed by the gradient norm plot. EG fails to resolve the convergence issue of GDA and performs similarly to GDA. With tuned gradient penalties, consensus optimization (CO) can successfully recover all three modes and obtain much smaller gradient norm. However, we notice that the gradient norm of CO decreases slowly and that both the generator and the discriminator have not converged after 50,000 iterations. In contrast, the generator
trained with FR successfully learns the true distribution with three modes and the discriminator is totally fooled by the generator. As expected, both players reach much lower gradient norm with FR, indicating fast convergence. Moreover, we find that even if initialized with GDA-trained networks (the top row of Fig. 4), FR can still find all the modes at the end of training.
To check whether FR fixes the strong rotation problem around fixed points, we follow Berard et al. (2019) to plot the gradient norm and path-angle (see Fig. 6). By interpolating between the initial parameters z and the final parameters z∗, they proposed to monitor the angle between the vector field v and the linear path from z to z∗. Specifically, they looked at the quantity – path-angle, defined as
θ(α) = 〈z∗ − z,vα〉 ‖z∗ − z‖‖vα‖ where vα = v(αz + (1− α)z∗).
They showed that a high “bump” around α = 0 in the path-angle plot typically indicates strong rotation behaviour. We choose α = [0.6, 1.2] and plot the gradient norm and path-angle along the linear path for the updates of FR. In particular, we only observe a sign-switch around the fixed point
z∗ without an obvious bump, suggesting that FR doesn’t exhibit rotational behaviour around the fixed point. To further check if FR converges to local minimax, we check the second-order condition of local minimax by computing the eigenvalues of Hxx −HxyH−1yyHyx and Hyy. As expected, all eigenvalues of Hxx −HxyH−1yyHyx are non-negative while all eigenvalues of Hyy are non-positive.
We also run FR on 2-D mixture of Gaussian with the same architectures (see Fig. 5) and compare it to vanilla GDA. Though GDA captures all the modes, we note that both the generator and the discriminator don’t converge which can be seen from the gradient norm plot in Fig. 12. In contrast, the discriminator trained by FR is totally fooled by the generator and gradients vanish. We stress here that the sample quality in GAN
models is not a good metric of checking convergence as we shown in the above example.

heading: 6.2.2 PRELIMINARY RESULTS ON MNIST
text: In a more realistic setting, we test our algorithm on image generation task. Particularly, we use the standard MNIST dataset (LeCun et al., 1998) but only take a subset of the dataset with class 0 and 1 for quick experimenting. To stabilize the training of GANs, we employ spectral normalization (Miyato et al., 2018) to enforce Lipschitz continuity on the discriminator. To ensure the invertibility of the discriminator’s Hessian, we add the same amount of L2 regularization to the discriminator as in mixture of Gaussian experiments. In terms of network architectures, we use 2-hidden-layers MLP with 512 hidden units in each layer for both the discriminator and the generator. For the discriminator, we use Sigmoid activation in the output layer. We use RMSProp as our base optimizer in the experiments with batch size 2,000. We run both GDA and FR for 100,000 iterations.
In Fig. 8, we show the generated samples of GDA and FR along with the gradient norm plots. Our main observation is that FR improves convergence as the gradient norms of both discriminator and generator decrease much faster than GDA; however the convergence is not well reflected by the quality of generated samples. We notice that gradients don’t vanish to zero at the end of training. We conjecture that for high-dimensional data distribution like images, the network we used is not flexible enough to learn the distribution perfectly.

heading: 7 CONCLUSION
text: In this paper, we studied local convergence of learning dynamics in minimax optimization. To address undesirable behaviours of gradient descent-ascent, we proposed a novel algorithm that locally converges to and only converges to local minimax by taking into account the sequential structure of minimax optimization. Meanwhile, we proved that our algorithm addresses the notorious rotational behaviour of vanilla gradient-descent-ascent around fixed points. We further showed theoretically that our algorithm is compatible with standard acceleration techniques, including preconditioning and positive momentum. Our algorithm can be easily extended to general-sum Stackelberg games with similar theoretical guarantees. Empirically, we validated the effectiveness of our algorithm in both low-dimensional toy problems and GAN training.

heading: ACKNOWLEDGEMENT
text: We thank Kefan Dong, Roger Grosse and Shengyang Sun for helpful comments on this project.

heading: A PROOF OF THEOREM 1
text: Proof. First of all, note that FR’s update rule can be rewritten as[ xt+1 yt+1 ] ← [ xt yt ] − ηx [ I −H−1yyHyx cI ] [ ∇xf −∇yf ] , (5)
where c := ηy/ηx, and that [
I −H−1yyHyx cI
] is always invertible. Therefore, the fixed points of FR
are exactly those that satisfy∇f(x,y) = 0, i.e., the first-order necessary condition of local minimax. Now, consider a fixed point (x∗,y∗). The Jacobian of FR’s update rule at (x∗,y∗) is given by
J = I− ηx [
I −H−1yyHyx I ] [ Hxx Hxy −cHyx −cHyy ] .
Observe that J is similar to[ I
H−1yyHyx I
] J [ I
−H−1yyHyx I ] =I− ηx [ I
H−1yyHyx I
] [ I
−H−1yyHyx I ] [ Hxx Hxy −cHyx −cHyy ] [ I −H−1yyHyx I ] =I− ηx [ Hxx −HxyH−1yyHyx Hxy
−cHyy
] ,
which is block diagonal. Therefore, the eigenvalues of J are exactly those of I+ ηyHyy and those of I− ηx(Hxx −HxyH−1yyHyx), which are all real because both matrices are symmetric. Moreover, suppose that
ηx < 2 max { ρ(Hxx −HxyH−1yyHyx), cρ(−Hyy) } , where ρ(·) stands for spectral radius. In this case
−I ≺ I + ηyHyy, −I ≺ I− ηx(Hxx −HxyH−1yyHyx).
Therefore whether ρ(J) < 1 depends on whether−Hyy or Hxx−HxyH−1yyHyx has negative eigenvalues. If (x∗,y∗) is a local minimax, by the necessary condition, Hyy 4 0, Hxx−HxyH−1yyHyx < 0. It follows that the eigenvalues of J all fall in (−1, 1]. (x∗,y∗) is thus a stable fixed point of FR. On the other hand, when (x∗,y∗) is a strictly stable fixed point, ρ(J) < 1. It follows that both Hyy and Hxx −HxyH−1yyHyx must be positive definite. By the sufficient conditions of local minimax, (x∗,y∗) is a local minimax.

heading: B PROOF OF THEOREM 2
text: Consider a general discrete dynamical system zt+1 ← g(zt). Let z∗ be a fixed point of g(·). Let J(z) denote the Jacobian of g(·) at z. Similar results can be found in many texts; see, for instance, Theorem 2.12 (Olver, 2015). Proposition 4 (Local convergence rate from Jacobian eigenvalue). If ρ(J(z∗)) = 1−∆ < 1, then there exists a neighborhood U of z∗ such that for any z0 ∈ U ,
‖zt − z∗‖2 ≤ C (
1− ∆ 2
)t ‖z0 − z∗‖2,
where C is some constant.
Proof. By Lemma 5.6.10 (Horn and Johnson, 2013), since ρ(J(z∗)) = 1−∆, there exists a matrix norm ‖ · ‖ induced by vector norm ‖ · ‖ such that ‖J(z∗)‖ < 1 − 3∆4 . Now consider the Taylor expansion of g(z) at the fixed point z∗:
g(z) = g(z∗) + J(z∗)(z− z∗) +R(z− z∗),
where the remainder term satisfies
lim z→z∗ R(z− z∗) ‖z− z∗‖ = 0.
Therefore, we can choose 0 < δ such that whenever ‖z− z∗‖ < δ, ‖R(z− z∗)‖ ≤ ∆4 ‖z− z ∗‖. In this case, ‖g(z)− g(z∗)‖ ≤ ‖J(z∗)(z− z∗)‖+ ‖R(z− z∗)‖
≤ ‖J(z∗)‖‖z− z∗‖+ ∆ 4 ‖z− z∗‖
≤ (
1− ∆ 2
) ‖z− z∗‖.
In other words, when z0 ∈ U = {z| ‖z− z∗‖ < δ}, ‖zt − z∗‖ ≤ (
1− ∆ 2
)t ‖z0 − z∗‖.
By the equivalence of finite dimensional norms, there exists constants c1, c2 > 0 such that ∀z, c1‖z‖2 ≤ ‖z‖ ≤ c2‖z‖2.
Therefore
‖zt − z∗‖2 ≤ c2 c1
( 1− ∆
2
)t ‖z0 − z∗‖2.
In other words, the rate of convergence is given by the gap between ρ(J) and 1. We now prove Theorem 2 using this view.
proof of Theorem 2. In the following proof we use ‖ · ‖ to denote the standard spectral norm. It is not hard to see that λmax(−Hyy) ≤ ρ(∇2f(x∗,y∗)) = β and ‖Hxy‖ ≤ β. Also,
λmax(Hxx −HxyH−1yyHyx) ≤ ‖Hxx‖+ ‖Hxy‖2 · ‖H−1yy‖ ≤ β + β2
α = (1 + κ)β.
Therefore we choose our learning rate to be ηx = ηy = 12κβ . In this case, the eigenvalues of the Jacobian of FR without momentum all fall in [ 0, 1− 12κ2 ] . Using Proposition 4, we can show that FR locally converges with a rate of Ω(κ−2). Now, let us consider FR with momentum:[ xt+1 yt+1 ] ← [ xt yt ] − ηx [ I −H−1yyHyx I ] [ ∇xf −∇yf ] + γ [ xt − xt−1 yt − yt−1 ] . (6)
This is a dynamical system on the augmented space of (xt,yt,xt−1,yt−1). Let J1 := I− ηx [
I −H−1yyHyx I ] [ Hxx Hxy −Hyx −Hyy ] be the Jacobian of the original FR at a fixed point (x∗,y∗). Then the Jacobian of Polyak’s momentum at (x∗,y∗,x∗,y∗) is
J2 :=
[ γI + J1 −γI
I 0
] .
The spectrum of J2 is given by solutions to det (λI− J2) = det ( (λ2 − γλ+ γ)I− γJ1 ) = 0.
In other words, an eigenvalue r of J1 corresponds to two eigenvalues of J2 given by the roots of λ2− (γ+r)λ+γ = 0. For our case, let us choose γ = 1+ 12κ2 − √ 2 κ . Then for any r ∈ [ 0, 1− 12κ2 ] ,
(r + γ)2 − 4γ ≤ (
1− 1 2κ2 + γ
)2 − 4γ = 0.
Therefore the two roots of λ2− (γ+ r)λ+ γ = 0 must be imaginary, and their magnitude are exactly√ γ. Since
√ γ ≤ 1− 1−γ2 ≤ 1− 1 2 √ 2κ , we now know that ρ(J2) ≤ 1− 12√2κ . Using Proposition 4,
we can see that FR with momentum locally converge with a rate of Ω(κ−1).

heading: C PROOFS FOR SECTION 4

heading: C.1 PRECONDITIONING
text: Recall that the preconditioned variant of FR is given by[ xt+1 yt+1 ] ← [ xt yt ] − [ I −H−1yyHyx I ] [ ηxP1∇xf −ηyP2∇yf ] . (7)
We now prove that preconditioning does not effect the local convergence properties. Proposition 5. If A is a symmetric real matrix, B is symmetric and positive definite, then the eigenvalues of AB are all real, and AB and A have the same number of positive, negative and zero eigenvalues.
Proof. AB is similar to and thus has the same eigenvalues as B 1 2AB 1 2 , which is symmetric and has real eigenvalues. Since B 1 2AB 1 2 is congruent to A, they have the same number of positive, negative and zero eigenvalues (see Horn and Johnson (2013, Theorem 4.5.8)).
Proposition 6. Assume that P1 and P2 are positive definite. The Jacobian of (7) has only real eigenvalues at fixed points. With a suitable learning rate, all strictly stable fixed points of (7) are local minimax, and all local minimax are stable fixed points of (7). Proof. First, observe that both [
I −H−1yyHyx I
] and [ P1
P2
] are both always invertible. Hence
fixed points of (7) are exactly stationary points. Let c := ηy/ηx. Note that the Jacobian of (7) is given by J = I− ηx [
I −H−1yyHyx I
] [ P1
P2 ] [ Hxx Hxy −cHyx −cHyy ] ,
which is similar to [ I
H−1yyHyx I
] J [ I
−H−1yyHyx I ] =I− ηx [ P1
P2
] [ Hxx −HxyH−1yyHyx Hxy
−cHyy
] .
Therefore the eigenvalues of J are exactly those of I − ηxP1 ( Hxx −HxyH−1yyHyx ) and I + ηyP2Hyy. By Proposition 5, the eigenvalues of both matrices are all real. When the learning rates are small enough, i.e., when
ηx < 2 max { ρ ( P1(Hxx −HxyH−1yyHyx) ) , cρ(−P2Hyy) } , whether ρ(J) ≤ 1 solely depends on whether P1 ( Hxx −HxyH−1yyHyx ) and −P2Hyy have negative eigenvalues. By Proposition 5, the number of positive, negative and zero eigenvalues of the two matrices are the same as those of Hxx −HxyH−1yyHyx and −Hyy respectively. Therefore the proposition follows from the same argument as in Theorem 1.

heading: C.2 GENERAL-SUM STACKELBERG GAMES
text: A general-sum Stackelberg game is formulated as follows. There is a leader, whose action is x ∈ Rn, and a follower, whose action is y ∈ Rm. The leader’s cost function is given by f(x,y) while the follower’s is given by g(x,y). The generalization of minimax in general-sum Stackelberg games is Stackelberg equilibrium. Definition 3 (Stackelberg equilibrium). (x∗,y∗) is a (global) Stackelberg equilibrium if y∗ ∈ R(x∗), and ∀x ∈ X ,
f(x∗,y∗) ≤ max y∈R(x) f(x,y),
where R(x) := arg min g(x, ·) is the best response set for the follower.
Similarly, we have local Stackelberg equilibrium (Fiez et al., 2019) defined as follows.5
Definition 4 (Local Stackelberg equilibrium). (x∗,y∗) is a local Stackelberg equilibrium if
1. y∗ is a local minimum of g(x∗, ·);
2. Let r(x) be the implicit function defined by ∇yg(x,y) = 0 in a neighborhood of x∗ with r(x∗) = y∗. Then x∗ is a local minimum of φ(x) := f(x, r(x)).
For local Stackelberg equilibrium, we have similar necessary conditions and sufficient conditions. For simplicity, we use the following notation when it is clear from the context
∇2f(x,y) = [ Hxx Hxy Hyx Hyy ] , ∇2g(x,y) = [ Gxx Gxy Gyx Gyy ] .
Similar to the zero-sum case, local Stackelberg equilibrium can be characterized using derivatives.
Proposition 7 (Necessary conditions). Any local Stackelberg equilibrium satisfies ∇yg(x,y) = 0, ∇xf(x,y)−GxyG−1yy∇yf(x,y) = 0,∇2yyg(x,y) < 0 and
Hxx −HxyG−1yyGyx −∇x ( GxyG −1 yy∇yf ) +∇y ( GxyG −1 yy∇yf ) G−1yyGyx < 0.
Proposition 8 (Sufficient conditions). If (x,y) satisfy ∇yg(x,y) = 0, ∇xf(x,y) − GxyG −1 yy∇yf(x,y) = 0,∇2yyg(x,y) 0 and
Hxx −HxyG−1yyGyx −∇x ( GxyG −1 yy∇yf ) +∇y ( GxyG −1 yy∇yf ) G−1yyGyx 0.
then (x,y) is a local Stackelberg equilibrium.
The conditions above can be derived from the definition with the observation that ∇2φ(x) = ∇ ( ∇xf(x, r(x))> −∇yf(x, r(x))>∇r(x) ) = ∇2xxf +∇2xyf∇r(x) +∇x ( ∇yf>∇r(x) ) +∇y ( ∇yf>∇r(x) ) ∇r(x)
= Hxx −HxyG−1yyGyx −∇x ( GxyG −1 yy∇yf ) +∇y ( GxyG −1 yy∇yf ) G−1yyGyx.
Here all derivatives are evaluated at (x, r(x)). We would like to clarify that by ∇xh, where h : Rn+m → R, we mean the partial derivative of h for the first n entries. Similarly for h : Rn+m → Rk, by∇xh we mean the first n columns of the Jacobian of h, which is k-by-(n+m). Henceforth we will use Dxf(x,y) to denote ∇xf −GxyG−1yy∇yf(x,y). The general-sum version of Follow-the-Ridge is given by[
xt+1 yt+1 ] ← [ xt yt ] − [ I −G−1yyGyx I ] [ ηxDxf(xt,yt) ηy∇yg(xt,yt) ] . (8)
Just as the zero-sum version of FR converges exactly to local minimax, we can show that the generalsum version of FR converges exactly to local Stackelberg equilibria. As in the zero-sum setting, we use stability of fixed points as a proxy of discussing local convergence.
Theorem 3. The Jacobian of (8) has only real eigenvalues at fixed points. With a suitable learning rate, all strictly stable fixed points of (8) are local Stackelberg equilibria, and all local Stackelberg equilibria are stable fixed points of (8).
Proof. This theorem only analyzes the Jacobian of (8) at fixed points; thus we will only need to focus on the fixed points of (8) in the proof.
Let c := ηy/ηx. Note that [
I −G−1yyGyx I
] is always invertible. Therefore, the fixed points of (8)
are exactly points (x,y) that satisfyDxf(x,y) = 0 and∇yg(x,y) = 0, i.e. the first-order necessary condition for local Stackelberg equilibria.
5Our definition is slightly different from that in Fiez et al. (2019)
In particular, consider a fixed point z∗ := (x,y). The Jacobian of (8) at (x,y) is given by J = I− ηx [
I −G−1yyGyx I
] [ Hxx −∇x(GxyG−1yy∇yf) Hxy −∇y(GxyG−1yy∇yf)
cGyx cGyy
] .
Observe that[ I
G−1yyGyx I
] J [ I
−G−1yyGyx I ] =I− ηx [ Hxx −∇x(GxyG−1yy∇yf) Hxy −∇y(GxyG−1yy∇yf)
cGyx cGyy
] [ I
−G−1yyGyx I ] =I− ηx [ Hxx −HxyG−1yyGyx −∇x ( ) +∇y ( )G−1yyGyx Hxy −∇y( )
0 cGyy
] ,
where is a shorthand for GxyG−1yy∇yf . Let
H̃xx := Hxx −HxyG−1yyGyx −∇x ( ) +∇y ( )G−1yyGyx.
We can now see that the eigenvalues of J are exactly those of I− ηxH̃xx and those of I− ηyGyy. It follows that all eigenvalues of J are real.6 Suppose that
ηx < 2
max{ρ(H̃xx), cρ (Gyy)} .
In that case, if (x,y) is a local Stackelberg equilibrium, then from the second-order necessary condition, both H̃xx and Gyy are positive semidefinite. As a result, all eigenvalues of J would be in (−1, 1]. By Definition 2, this suggests that (x,y) is a stable fixed point. On the other hand, if (x,y) is a strictly stable fixed point, then all eigenvalues of J fall in (−1, 1), which suggests that H̃xx 0 and Gyy 0. By the sufficient condition, (x,y) is a local Stackelberg equilibrium.
Remark 2. From the proof above, it is can be seen that “strict local Stackelberg equilibria”, i.e. points that satisfy the sufficient conditions, must be strictly stable fixed points of (8). Then by Proposition 4, FR locally converges to such points. Thus, the set of points that FR locally converges to is the same as local Stackelberg equilibria, up to degenerate cases where the Jacobian spectral radius is exactly 1.

heading: D EXPERIMENTAL DETAILS

heading: D.1 LOW DIMENSIONAL PROBLEMS
text: The algorithms we compared with are[ xt+1 yt+1 ] ← [ xt yt ] − η [ ∇xf(xt,yt) −∇yf(xt,yt) ] , (GDA)[
xt+1 yt+1 ] ← [ xt yt ] − 2η [ ∇xf(xt,yt) −∇yf(xt,yt) ] + η [ ∇xf(xt−1,yt−1) −∇yf(xt−1,yt−1) ] , (OGDA)[
xt+1 yt+1 ] ← [ xt yt ] − η [ ∇xf(xt − η∇xf(xt,yt),yt + η∇yf(xt,yt)) −∇yf(xt − η∇xf(xt,yt),yt + η∇yf(xt,yt)) ] , (EG)[
xt+1 yt+1 ] ← [ xt yt ] − η [ I −λHxy λHyx I ] [ ∇xf(xt,yt) −∇yf(xt,yt) ] , (SGA)[
xt+1 yt+1 ] ← [ xt yt ] − η [ ∇xf(xt,yt) −∇yf(xt,yt) ] − γη∇‖∇f(xt,yt)‖2 . (CO)
We used a learning rate of η = 0.05 for all algorithms, λ = 1.0 for SGA and γ = 0.1 for CO. We did not find SGA with alignment (Balduzzi et al., 2018) to be qualitatively different from SGA in our experiments.
6H̃xx is always symmetric.

heading: D.2 MIXTURE OF GAUSSIAN EXPERIMENT
text: Dataset. The mixture of Gaussian dataset is composed of 5,000 points sampled independently from the following distribution pD(x) = 13N (−4, 0.01) + 1 3N (0, 0.01) + 1 3N (4, 0.01) where N (µ, σ 2) is the probability density function of a 1D-Gaussian distribution with mean µ and variance σ2. The latent variables z ∈ R16 are sampled from a standard Normal distribution N (0, I). Because we want to use full-batch methods, we sample 5,000 points that we re-use for each iteration during training. For the two-dimensional case, we generate the data from 9 Gaussians with µx ∈ {−3, 0, 3} and µy ∈ {−3, 0, 3}. The covariance matrix is 0.01I. Neural Networks Architecture. Both the generator and discriminator are 2 hidden layer neural networks with 64 hidden units and Tanh activations.
Other Hyperparameters. For FR, we use conjugate gradient (CG) in the inner-loop to approximately invert the Hessian. In practice, we use 10 CG iterations (5 iterations also works well). Since the loss surface is highly non-convex (let alone quadratic), we add damping term to stabilize the training. Specifically, we follow Levenberg-Marquardt style heuristic adopted in Martens (2010). For both generator and discriminator, we use learning rate 0.0002. For consensus optimization (CO), we tune the gradient penalty coefficient using grid search over {0.01, 0.03, 0.1, 0.3, 1.0, 3.0, 10.0}.

heading: D.3 MNIST EXPERIMENT
text: Dataset. The dataset we used in our experiment only includes class 0 and 1. For each class, we take 4,800 training examples. Overall, we have 9,800 examples. The latent variables z ∈ R64 are sampled from a standard Normal distribution N (0, I). Neural Networks Architecture. Both the generator and discriminator are 2 hidden layer neural networks with 512 hidden units and Tanh activations. For each fully-connected layer, we use spectral normalization to stabilize training.
Other Hyperparameters. For FR, we use conjugate gradient (CG) in the inner-loop to approximately invert the Hessian. In practice, we use 5 CG iterations for computational consideration. We also use the same damping scheme as MOG experiment. For both generator and discriminator, we use learning rate 0.0001. We use batch size 2,000 in our experiments.

heading: D.4 COMPUTING CORRECTION TERM ON MOG AND MNIST EXPERIMENTS
text: The main innovation of this work is the introduction of the correction term which encourages both players (leader and follower) to stay close to the ridge. In the main paragraph, we focused on local convergence of our algorithm and essentially the Hessian matrix is constant. However, we know that the curvature (Hessian) of the loss surface might change rapidly in practice especially when both players are parameterized by deep neural networks, making the computation of Hessian inverse highly non-trivial. Here, we summarize detailed steps in computing ηxH−1yyHyx∇xf :
1. Computing ηxHyx∇xf by finite difference b := ∇yf(x,y)−∇yf(x− ηx∇xf,y); 2. Assigning x← x− ηx∇xf such that the Hessian H below are evaluated at the updated x; 3. Solving linear system ( H2yy + λI ) ∆y = Hyyb using conjugate gradient to get an approx-
imation of ∆y = ( H2yy + λI )−1 Hyyb ≈ ηxH−1yyHyx∇xf ;
4. Adapting the damping coefficient λ by computing reduction ratio
ρ = ‖b‖22 − ‖∇yf(x,y)−∇yf(x− ηx∇xf,y + ∆y)‖22
‖b‖22 − ‖Hyy∆y − b‖22 ,
which measures whether the loss surface is locally quadratic or not. We note that ρ should be exactly 1 in the quadratic case if λ = 0. We then adjust the damping with LevenbergMarquardt style heuristic (Martens, 2010) as follows:
λ←−  1.1λ if 0 < ρ ≤ 0.5 0.9λ if ρ > 0.95 2.0λ if ρ ≤ 0 λ otherwise
5. Setting ∆y← 0 if ρ ≤ 0 (essentially we don’t believe the approximation if ρ is negative).
When momentum or preconditioning is applied, we modify∇xf above with the momentum or preconditioned version. To be specific, we apply momentum and preconditioning before the computation of the correction term, Here, we give an example of FR with momentum:[
xt+1 yt+1 ] ← [ xt yt ] − [ I −H−1yyHyx I ] [ ηx∇xf + γmx,t −ηy∇yf + γmy,t ] [ mx,t+1 my,t+1 ] ← [ γmx,t + ηx∇xf γmy,t − ηy∇yf
] (9) which is equivalent to Eqn.(3) in the quadratic case since it is a linear dynamical system. Nevertheless, we argue that it is more effective to use Eqn.(9) when the loss surface is highly non-quadratic.

heading: E ADDITIONAL RESULTS

heading: E.1 THE ROLE OF PRECONDITIONING
text: Following the same setting as Fig. 4, we investigate the effect of preconditioning for our algorithm. As we shown in section 4.1, FR is compatible with preconditioning with same theoretical convergence guarantee. In Fig. 4, we use diagonal preconditioning for accelerating the training. Here, we report the results of FR without preconditioning in Fig. 9. For fair comparison, we also tune the learning rate for vanilla FR and the optimal learning rate is 0.05. Our first observation is that vanilla FR does converge with 500,000 iterations which is consistent with our theoretical results. Particularly, the discriminator is being fooled at the end of training and the gradient vanishes. Our second observation is that it takes much longer to converge, which can be seen from the comparison between the second column (preconditioned version) and the third column. With the same time budget (50,000 iterations), preconditioned FR already converges as seen from the gradient norm curves while the vanilla FR is far from converged.

heading: E.2 THE ROLE OF MOMENTUM
text: In this subsection, we discuss the effect of momentum in our algorithm. We first consider the following quadratic problem:
f(x,y) = −0.45x21 − 0.5x22 − 0.5y21 − 0.05y22 + x1y2 + x2y2. In this problem, (0,0) is a local (and global) minimax. We run FR with learning rate η = 0.2 and momentum values γ ∈ {0.0, 0.5, 0.8}, and observe how fast the iterates approach the origin. We also compare FR with gradient descent-ascent in this problem. Note that when learning rate ratio (ratio of the follower’s learning rate to the leader’s learning rate) is 1, GDA diverges. We use
a grid search for the follower’s learning rate ηy ∈ {0.1, 0.2, 0.4, 0.8, 1.6} and learning rate ratio c ∈ {5, 10, 20, 40, 80}. We experiment with momentum γ ∈ {0.0,±0.1,±0.2,±0.4,±0.8}. The best result for GDA without momentum is achieved by ηy = 0.8, c = 20; the best result for GDA with momentum is achieved by ηy = 1.6, c = 40 and γ = 0.2. The results are plotted in Fig. 10.
We can see that momentum speeds up FR dramatically. In contrast, GDA with momentum does not improve much over GDA without momentum. Moreover, under large momentum values (i.e. γ = 0.8), GDA diverges even when using very large learning rate ratios.
We further test the acceleration effect of momentum on the mixture of Gaussian benchmark. Keeping all other hyperparameters the same as those used in Fig. 4, we conduct experiments with momentum coefficient γ ∈ {0.8, 0.9}. As shown in the gradient norm plots of Fig. 11, FR with large positive momentum coefficient converges faster than the one with zero momentum (the second column). Particularly, FR is able to converge within 10,000 iterations with γ = 0.9, yielding roughly a factor of 3 improvement in terms of convergence.

heading: E.3 SPECTRUM FOR GAN MODEL
text: As we claimed in Section 6.2.1, all eigenvalues of Hxx − HxyH−1yyHyx are nonnegative while all eigenvalues of Hyy are non-positive. Here we plot all eigenvalues of them in log scale. To be noted, we plot the eigenvalues for −Hyy for convenience. As expected, the Hessian matrix for the
discriminator is negative semi-definite while the Schur compliment is positive semi-definite.

Review summaries:
This paper designs a set of dynamics for learning in games called follow-the-ridge with the goal of finding local stackelberg equilibria. The main theoretical results show that the only stable attractors of the dynamics are stackelberg equilibria. Moreover, the authors give a deterministic convergence rate for the vanilla algorithm and a convergence rate using momentum. Empirical results show the learning dynamics cancel out rotational components and drive the vector field to zero rapidly, while reaching good performance on simple GAN examples.

The present work proposes a new algorithm, "Follow the Ridge" (FR) that uses second order gradient information to iteratively find local minimax points, or Stackelberg equilibria in two player continuous games. The authors show rigorously that the only stable fixed points of their algorithm are local minimax points and that their algorithm therefore converges locally exactly to those points. They show that the resulting optimizer is compatible with heuristics like RMSProp and Momentum. They further evaluate their algorithm on polynomial toy problems and simple GANs.