O N S OLVING M INIMAX O PTIMIZATION L OCALLY : A F OLLOW - THE -R IDGE A PPROACH
A BSTRACT
Many tasks in modern machine learning can be formulated as ﬁnding 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 ﬁnd 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 algorithms 1 .
I NTRODUCTION
[Figure]
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. ,
[Equation]
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 ﬁrst is crucial for the problem.
Therefore, the classical notion of local Nash equilibrium from simultaneous games may not be a proper deﬁnition of local optima for sequential games since minimax 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 ﬁxed points that are not local minimax (Jin et al., 2019;
Daskalakis and
Panageas, 2018).
Second, GDA exhibits strong rotation around ﬁxed 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.
Speciﬁcally, we elucidate the cause of undesirable convergence of GDA – the is at: 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 satisﬁed when the leader moves inﬁnitely 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 ﬁxed 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 signiﬁcantly.
• 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.
P RELIMINARIES 2. M INIMAX O PTIMIZATION
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 ∈ R n , and the follower’s action by y ∈ R m .
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.
∇ 2 yy f is invertible (i.e., non-singular).
The global solution to the sequential game min x max y 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, ﬁnding this global minimax is often intractable; therefore, we follow Jin et al.
and take local minimax as the local surrogate.
Deﬁnition 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 deﬁned by ∇ y f
( x , y ) =
in a neighborhood of x ∗ with r ( x ∗ )
=
y ∗ .
In the deﬁnition above, the implicit function r ( · ) : R n → R m 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 deﬁne
[Equation]
In principle, local minimax can be characterized in terms of the following ﬁrst-order and second-order conditions, which were established in Jin et al.
Proposition 1 (First-order Condition) .
Any local minimax ( x ∗ , y ∗ ) satisﬁes ∇ f ( x ∗ , y ∗ )
= 0 .
Proposition 2 (Second-order Necessary Condition) .
Any local minimax ( x ∗ , y ∗ ) satisﬁes H yy (
cid:52)and H xx − H
xy H −
yy H yx (cid:60) 0 .
Proposition 3 (Second-order Sufﬁcient Condition) .
Any stationary point ( x ∗ , y ∗ ) satisfying H yy ≺ 0 and H xx − H
xy
H − 1 yy H yx (cid:31) 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.
; Ratliff et al.
(2016) for more details).
In particular, we note that the concept of Nash equilibrium or local
Nash does not reﬂect 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 ﬁxed 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. S TABILITY OF DISCRETE DYNAMICAL SYSTEMS
Gradient-based methods can reliably ﬁnd local stable ﬁxed 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 z t +1 = w ( z t ) can be viewed as a discrete dynamical system, where in our case w : R n + m → R n + m .
If w ( z ) =
z , then z is called a ﬁxed point.
We study the stability of ﬁxed points as a proxy to local convergence of game dynamics.
Deﬁnition 2.
Let J denote the Jacobian of w at a ﬁxed point z .
If it has spectral radius ρ ( J ) ≤ 1 , then we call z a stable ﬁxed point.
If ρ ( J ) < 1 , then we call z a strictly stable ﬁxed point.
It is known that strict stability implies local convergence ( e.g. , see Galor (2007)).
In other words, if z is a strictly stable ﬁxed point, there exists a neighborhood U of z such that when initialized in U , the iteration steps always converge to z .
U NDESIRABLE B EHAVIOURS OF GDA
In this section, we discuss the undesirable behaviours of GDA in more detail.
Recall that the update rule of GDA is given by
[Equation]
where we assume the same learning rate for both the leader and the follower for simplicity 2 .
As illustrated in Fig.
2, the set of stable ﬁxed points of GDA can include points that are not local minimax and, perhaps even worse, some local minimax are not necessarily stable ﬁxed points of
GDA.
Here, we ﬁrst give an example that a stable ﬁxed point of GDA is not a local minimax.
Consider min x max y f
( x, y ) = 3 x 2 + y 2 + 4 xy ; the only stationary point of this problem is (0 , 0) and the
Jacobian of GDA at this point is
[Equation]
It is easy to see that the eigenvalues of J are e 1 =
e 2 = 1 − 2 η .
Therefore, by Deﬁnition 2, (0 , 0) is a strictly stable ﬁxed point of GDA.
However, one can show that H yy = 2 > 0 which doesn’t satisfy the second-order necessary condition of local minimax.
Similarly, one can easily ﬁnd examples in which a local minimax is not in the set of stable ﬁxed points of GDA, e.g. , min x ∈ R max y ∈ R
f
( x, y )
= − 3 x 2 − y 2 + 4 xy
(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 − η ∇ x f pushes the whole system away from the ridge or attracts the system to non-local-minimax points.
By contrast, the follower’s step η ∇ y f can pull the system closer to the ridge (see Fig. 1) or push it away from bad ﬁxed points.
To guarantee convergence to local minimax (or avoid bad ﬁxed points), we have to use a very small learning rate for the leader (Jin et al., 2019; Fiez et al., 2019) so that the η ∇ y f term dominates.
In the next section, we offer an alternative approach which explicitly cancels out undesirable effects of − η ∇ x f , thereby allowing us to use larger learning rates for the leader.
F OLLOW THE R IDGE
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 modiﬁes gradient descent-ascent by applying an asymmetric preconditioner.
The update rule is described in Algorithm.
Algorithm in blue Require: Learning rate η x and η y ; number of iterations T .
1: for
[Equation]
[Equation]
The main intuition behind FR is the following.
Suppose that y t is a local maximum of f ( x t , · ) .
Let r ( x ) be the implicit function deﬁned by ∇ y f
( x , y ) = 0 around ( x t , y t ) , i.e. , a ridge in the landscape of f ( x , y ) .
By deﬁnition, a local minimax has to lie on a ridge; hence, it is intuitive to follow the ridge during learning.
However, if ( x t , y t ) is on the ridge, then ∇ y f ( x t , y t ) = 0 , and one step of gradient descent-ascent will take ( x t , y t ) to ( x t − η x ∇ x f, y t ) , which is off the ridge.
In other words, gradient descent-ascent tends to drift away from the ridge.
The correction term we introduce is
[Equation]
It would bring y t to y t + ∇ x r ( x )( x t +1 − x t )
≈ r
( x t +1 ) , thereby encouraging both players to stay along the ridge.
When ( x t , y t ) is not on a ridge yet, we expect the − η x ∇ x f term and the η x H − 1 yy H yx ∇ x f term to move parallel to the ridge, while the η y ∇ y f term brings ( x t , y t ) 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 ﬁxed points of
FR are local minimax, and all local minimax points are stable ﬁxed points of FR.
The proof is mainly based on the following observation.
The Jacobian of FR dynamics at a ﬁxed point ( x ∗ , y ∗ ) is ( c :=
η y /η x )
[Equation]
where the Hessians are evaluated at ( x ∗ , y ∗ ) .
J is similar to
[Equation]
Therefore, the eigenvalues of J are those of I + η y H yy and those of I − η x
( H xx − H xy H − 1 yy H yx ) .
As shown in second-order necessary condition 2, ( x ∗ , y ∗ ) being a local minimax implies H yy (
cid:52)and H xx − H
xy H −
yy H yx (cid:60) 0 ; one can then show that the spectral radius of the Jacobian satisﬁes ρ ( J ) ≤ 1 ; hence ( x ∗ , y ∗ ) is a stable ﬁxed point by Deﬁnition 2.
On the other hand, when ρ ( J ) < 1 , by the sufﬁcient 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 H yy and H
xx − H
xy H −
yy H yx are symmetric matrices.
As noted by Mescheder et al.
; Gidel et al.
Balduzzi et al.
, the rotational behaviour (instability) of GDA is caused by eigenvalues with large imaginary part.
Therefore, FR addresses the strong rotation problem around ﬁxed points as all eigenvalues are real.
4. A CCELERATING C ONVERGENCE WITH P RECONDITIONING AND M OMENTUM
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
[Equation]
We can show that with any constant positive deﬁnite preconditioners P 1 and P 2 , 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 signiﬁcantly 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:
[Equation]
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 (cid:8) λ min ( − H yy ) , λ min (
H xx − H
xy H − 1 yy H yx ) (cid:9) , β = ρ (cid:0) ∇ 2 f ( x ∗ , y ∗ ) (cid:1) , κ := β/α .
Then FR converges asymptotically to ( x ∗ , y ∗ ) with a rate Ω( κ − 2 ) ;
FR with a momentum parameter of γ = 1 − Θ (cid:0) κ − 1 (cid:1) converges asymptotically with a rate Ω( κ − 1 ) .
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.
4. G ENERAL S TACKELBERG G AMES
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:
[Equation]
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:
[Equation]
It can be seen that minimax optimization is the special case when g = − f .
Similarly, one can deﬁne 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 ﬁnding 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):
[Equation]
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.)
R ELATED W ORK
As a special case of Stackelberg games (Ratliff et al., 2016) in the zero-sum setting, minimax optimization concerns the problem of solving min x ∈X max y ∈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,
Raﬁque et al.
; Lu et al.
; Lin et al.
; 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 ﬁnd global optimum efﬁciently 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 ﬁxed points (Mescheder et al., 2017; Balduzzi et al., 2018).
To overcome this rotation behaviour of
GDA, various modiﬁcations 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 inﬁnitely slower than the follower, which may cause slow convergence due to inﬁnitely 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.
; Mazumdar et al.
(2019) attempt to solve the undesirable convergence issue of GDA by exploiting curvature information, but they focus on simultaneous game on ﬁnding 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 welldeﬁned, 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 speciﬁc optimization problem and convergence issues arise in theory and in practice; hence our algorithm is orthogonal to these work.
E XPERIMENTS
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. [Figure]
6. L OW D IMENSIONAL T OY E XAMPLES
To verify our claim on exact local convergence, we ﬁrst 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:
[Equation]
Here g 1 and g 2 are two-dimensional quadratic problems, which are arguably the simplest nontrivial problems.
g 3 is a sixth-order polynomial scaled by an exponential, which has a relatively complicated landscape compared to g 1 and g 2 .
It can be seen that when running in g 1 , 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 g 2 , where (0 , 0) is not a local minimax, all algorithms except for FR converges to this undesired stationary point 4 .
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 g 3 , 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 ﬁxed point or converge to bad ﬁxed points, whereas FR always exhibits desirable behaviors.
6. G ENERATIVE A DVERSARIAL N ETWORKS
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 ﬁrst, while the discriminator is the follower that helps the generator to learn the target data distribution.
6.2. M IXTURE OF G AUSSIANS
We ﬁrst 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 L 2 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 [Figure] [Figure] gradient (Martens, 2010; Nocedal and Wright, 2006) to solve the linear system in the inner loop.
To be speciﬁc, instead of solving H
yy z
= H yx ∇ x f directly, we solve H 2 yy
z
= H
yy H yx ∇ x f to ensure that the problem is well-posed since H 2 yy is always positive semideﬁnite.
For all experimental details, we refer readers to Appendix D.2.
[Figure]
As shown in Fig.
4, GDA suffers from the “missing mode” problem and both discriminator and generator fail to converge as conﬁrmed 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 ﬁnd that even if initialized with GDA-trained networks (the top row of Fig. 4), FR can still ﬁnd all the modes at the end of training.
To check whether FR ﬁxes the strong rotation problem around ﬁxed 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 ﬁnal parameters z ∗ , they proposed to monitor the angle between the vector ﬁeld v and the linear path from z to z ∗ .
Speciﬁcally, they looked at the quantity – path-angle, deﬁned as
[Equation]
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 ﬁxed point z ∗ without an obvious bump, suggesting that FR doesn’t exhibit rotational behaviour around the ﬁxed point.
To further check if FR converges to local minimax, we check the second-order condition of local minimax by computing the eigenvalues of H
xx − H xy H − 1 yy H yx and H
yy .
As expected, all eigenvalues of H
xx − H xy H − 1 yy H yx are non-negative while all eigenvalues of H yy are non-positive.
[Figure]
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.
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.
6.2. P RELIMINARY R ESULTS ON MNIST
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 L 2 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.
[Figure]
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 reﬂected 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 ﬂexible enough to learn the distribution perfectly.
C ONCLUSION
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 ﬁxed 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.
A CKNOWLEDGEMENT
We thank Kefan Dong, Roger Grosse and Shengyang Sun for helpful comments on this project.
A P ROOF OF T HEOREM
Proof.
First of all, note that FR’s update rule can be rewritten as
[Equation]
where c :=
η y /η x , and that
[Equation]
(cid:21) is always invertible.
Therefore, the ﬁxed points of FR are exactly those that satisfy ∇ f ( x , y )
= 0 , i.e. , the ﬁrst-order necessary condition of local minimax.
Now, consider a ﬁxed point ( x ∗ , y ∗ ) .
The Jacobian of FR’s update rule at ( x ∗ , y ∗ ) is given by
[Equation]
Observe that J is similar to
[Equation]
which is block diagonal.
Therefore, the eigenvalues of J are exactly those of I + η y H yy and those of
I − η x
( H xx − H xy H − 1 yy H yx ) , which are all real because both matrices are symmetric.
Moreover, suppose that
[Equation]
where ρ ( · ) stands for spectral radius.
In this case
[Equation]
Therefore whether ρ ( J ) < 1 depends on whether − H yy or H xx − H
xy H − 1 yy H yx has negative eigenvalues.
If ( x ∗ , y ∗ ) is a local minimax, by the necessary condition, H yy (cid:52) 0 ,
H xx − H
xy H −
yy H yx (cid:60) 0 .
It follows that the eigenvalues of J all fall in ( − 1 , 1] .
( x ∗ , y ∗ ) is thus a stable ﬁxed point of FR.
On the other hand, when ( x ∗ , y ∗ ) is a strictly stable ﬁxed point, ρ ( J ) < 1 .
It follows that both H yy and H xx − H
xy H −
yy H yx must be positive deﬁnite.
By the sufﬁcient conditions of local minimax, ( x ∗ , y ∗ ) is a local minimax.
B P ROOF OF T HEOREM
Consider a general discrete dynamical system z t +1 ← g ( z t ) .
Let z ∗ be a ﬁxed 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 z 0 ∈ U ,
[Equation]
where C is some constant.
Proof.
By Lemma 5.6.10 (Horn and Johnson, 2013), since ρ ( J ( z ∗ ))
= 1 − ∆ , there exists a matrix norm (cid:107) · (cid:107) induced by vector norm (cid:107) · (cid:107) such that (cid:107) J
( z ∗ ) (cid:107) < 1 − 3∆4 .
Now consider the Taylor expansion of g ( z ) at the ﬁxed point z ∗ :
[Equation]
where the remainder term satisﬁes
[Equation]
Therefore, we can choose 0 < δ such that whenever (cid:107) z
[Equation]
z
[Equation]
< δ ,
[Equation]
R
[Equation]
z
[Equation]
z
[Equation]
[Equation]
≤ ∆
[Equation]
z − z ∗ (cid:107) .
In this case,
[Equation]
In other words, when z 0 ∈ U = { z |
[Equation]
δ [Equation]
[Equation]
By the equivalence of ﬁnite dimensional norms, there exists constants c 1 , c 2 > 0 such that
[Equation]
Therefore
[Equation]
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 (cid:107) · (cid:107) to denote the standard spectral norm.
It is not hard to see that λ max ( − H yy )
≤ ρ ( ∇ 2 f ( x ∗ , y ∗ ))
=
β and (cid:107) H xy (cid:107) ≤ β .
Also,
[Equation]
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 (cid:2) 0 , 1 − 12 κ 2 (cid:3) .
Using Proposition 4, we can show that
FR locally converges with a rate of Ω( κ − 2 ) .
Now, let us consider FR with momentum:
[Equation]
This is a dynamical system on the augmented space of ( x t , y t , x t − 1 , y t − 1 ) .
Let
[Equation]
be the Jacobian of the original FR at a ﬁxed point ( x ∗ , y ∗ ) .
Then the Jacobian of Polyak’s momentum at ( x ∗ , y ∗ , x ∗ , y ∗ ) is
[Equation]
The spectrum of J 2 is given by solutions to
[Equation]
In other words, an eigenvalue r of J 1 corresponds to two eigenvalues of J 2 given by the roots of λ 2 − ( γ + r ) λ + γ = 0 .
For our case, let us choose γ = 1+ 12 κ 2 − √ 2 κ .
Then for any r ∈ (cid:2) 0 , 1 − 12 κ 2 (cid:3) ,
[Equation]
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 ρ ( J 2 ) ≤ 1 − 1 2 √ 2 κ .
Using Proposition 4, we can see that FR with momentum locally converge with a rate of Ω( κ − 1 ) .
C P ROOFS FOR S ECTIONC. P RECONDITIONING
Recall that the preconditioned variant of FR is given by
[Equation]
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 deﬁnite, 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 12 AB 12 , which is symmetric and has real eigenvalues.
Since B 12 AB 12 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 P 1 and P 2 are positive deﬁnite.
The Jacobian of (7) has only real eigenvalues at ﬁxed points.
With a suitable learning rate, all strictly stable ﬁxed points of (7) are local minimax, and all local minimax are stable ﬁxed points of (7).
Proof.
First, observe that both
[Equation]
and
[Equation]
P
[Equation]
P
[Equation]
are both always invertible.
Hence ﬁxed points of (7) are exactly stationary points.
Let c :=
η y /η x .
Note that the Jacobian of (7) is given by
[Equation]
which is similar to (cid:20)
[Equation]
Therefore the eigenvalues of J are exactly those of I − η x P 1 (cid:0)
H xx − H
xy H −
yy H yx (cid:1) and I + η y P 2 H
yy .
By Proposition 5, the eigenvalues of both matrices are all real.
When the learning rates are small enough, i.e. , when
[Equation]
whether ρ ( J ) ≤ 1 solely depends on whether P 1 (cid:0) H
xx − H
xy H −
yy H yx (cid:1) and − P 2 H yy have negative eigenvalues.
By Proposition 5, the number of positive, negative and zero eigenvalues of the two matrices are the same as those of H
xx − H xy H − 1 yy H yx and − H
yy respectively.
Therefore the proposition follows from the same argument as in Theorem 1.
C. G ENERAL - SUM S TACKELBERG G AMES
A general-sum Stackelberg game is formulated as follows.
There is a leader, whose action is x ∈ R n , and a follower, whose action is y ∈ R m .
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 .
Deﬁnition 3 (Stackelberg equilibrium) .
( x ∗ , y ∗ ) is a (global) Stackelberg equilibrium if y ∗ ∈ R ( x ∗ ) , and ∀ x ∈ X ,
[Equation]
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) deﬁned as follows.
Deﬁnition 4 (Local Stackelberg equilibrium) .
( x ∗ , y ∗ ) is a local Stackelberg equilibrium if
y ∗ is a local minimum of g ( x ∗ , · )
Let r ( x ) be the implicit function deﬁned by ∇ y g
( x , y ) =
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 sufﬁcient conditions.
For simplicity, we use the following notation when it is clear from the context
[Equation]
Similar to the zero-sum case, local Stackelberg equilibrium can be characterized using derivatives.
Proposition 7 (Necessary conditions) .
Any local Stackelberg equilibrium satisﬁes ∇ y g
( x , y ) = 0 ,
[Equation]
G
[Equation]
x
[Equation]
y
[Equation]
= 0 , ∇ 2 yy g
( x , y ) (cid:60) {+
+} and
[Equation]
Proposition 8 (Sufﬁcient conditions) .
If ( x , y ) satisfy ∇ y g ( x , y ) = 0 , ∇ x f ( x , y ) −
G xy G − 1 yy ∇ y f
( x , y ) = 0 , ∇ 2 yy g ( x , y ) (cid:31) 0 and H
[Equation]
then ( x , y ) is a local Stackelberg equilibrium.
The conditions above can be derived from the deﬁnition with the observation that
[Equation]
Here all derivatives are evaluated at ( x , r ( x )) .
We would like to clarify that by ∇ x h , where h : R n + m → R , we mean the partial derivative of h for the ﬁrst n entries.
Similarly for h : R n + m → R k , by ∇ x h
we mean the ﬁrst n columns of the Jacobian of h , which is k -by-( n + m ).
Henceforth we will use D x f ( x , y ) to denote ∇ x f − G xy G − 1 yy ∇ y f ( x , y ) .
The general-sum version of Follow-the-Ridge is given by
[Equation]
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 ﬁxed points as a proxy of discussing local convergence.
Theorem 3.
The Jacobian of (8) has only real eigenvalues at ﬁxed points.
With a suitable learning rate, all strictly stable ﬁxed points of (8) are local Stackelberg equilibria, and all local Stackelberg equilibria are stable ﬁxed points of (8).
Proof.
This theorem only analyzes the Jacobian of (8) at ﬁxed points ; thus we will only need to focus on the ﬁxed points of (8) in the proof.
Let c :=
η y /η x .
Note that
[Equation]
is always invertible.
Therefore, the ﬁxed points of (8) are exactly points ( x , y ) that satisfy D x f ( x , y )
=
and ∇ y g ( x , y ) = 0 , i.e. the ﬁrst-order necessary condition for local Stackelberg equilibria.
In particular, consider a ﬁxed point z ∗ :=
( x , y ) .
The Jacobian of (8) at ( x , y ) is given by
[Equation]
Observe that
[Equation]
where (cid:3) is a shorthand for G xy G − 1 yy ∇ y f .
Let
[Equation]
We can now see that the eigenvalues of J are exactly those of I − η x (cid:101)
H xx and those of I − η y G yy .
It follows that all eigenvalues of J are real.
6 Suppose that
[Equation]
In that case, if ( x , y ) is a local Stackelberg equilibrium, then from the second-order necessary condition, both (cid:101)
H xx
and G yy are positive semideﬁnite.
As a result, all eigenvalues of J would be in ( − 1 , 1] .
By Deﬁnition 2, this suggests that ( x , y ) is a stable ﬁxed point.
On the other hand, if ( x , y ) is a strictly stable ﬁxed point, then all eigenvalues of J fall in ( − 1 , 1) , which suggests that (cid:101) H xx (cid:31) 0 and G yy (cid:31) 0 .
By the sufﬁcient 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 sufﬁcient conditions, must be strictly stable ﬁxed 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 .
D E XPERIMENTAL D ETAILS D. L OW D IMENSIONAL P ROBLEMS
The algorithms we compared with are (cid:20)
[Equation]
+ y t
[Equation]
(cid:21) ← (cid:20)
[Equation]
t y t (cid:21) − η (cid:20) ∇
[Equation]
f ( x t , y t ) −∇ y f
( x t , y t ) (cid:21) , (GDA) (cid:20) x t + y t + (cid:21) ← (cid:20) x t y t (cid:21) − 2 η (cid:20) ∇ x f ( x t , y t ) −∇
y f
( x t , y t ) (cid:21) + η (cid:20) ∇ x f ( x t − 1 , y t − 1 )
−∇ y f
( x t − 1 , y t − 1 ) (cid:21) , (OGDA) (cid:20) x
t + y t + (cid:21) ← (cid:20) x
t y t (cid:21) − η (cid:20) ∇ x f ( x t − η ∇ x f ( x t , y t ) , y t + η ∇ y f
( x t , y t ))
−∇ y f
( x t − η ∇ x f ( x t , y t ) , y t + η ∇ y f ( x t , y t ))
(cid:21) , (EG) (cid:20) x t + y t + (cid:21) ← (cid:20) x
t y t (cid:21) − η (cid:20)
I − λ
H xy λ H yx
I (cid:21) (cid:20) ∇ x f ( x t , y t ) −∇ y f ( x t , y t ) (cid:21) , (SGA) (cid:20) x t + y t + (cid:21) ← (cid:20) x
t y t (cid:21) − η (cid:20) ∇ x f ( x t , y t ) −∇
y f
( x t , y t ) (cid:21) − γη ∇ (cid:107)∇ f ( x t , y t ) (cid:107) 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 ﬁnd SGA with alignment (Balduzzi et al., 2018) to be qualitatively different from SGA in our experiments.
D. M IXTURE OF G AUSSIAN E XPERIMENT
Dataset.
The mixture of Gaussian dataset is composed of 5,000 points sampled independently from the following distribution p D ( x ) = 13 N ( − 4 , 0 . 01) + 13 N (0 , 0 . 01)
+ 13 N (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 ∈ R 16 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 .
01 I .
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.
Speciﬁcally, 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 coefﬁcient using grid search over { 0 . 01 , 0 . 03 , 0 . 1 , 0 . 3 , 1 . 0 , 3 . 0 , 10 . 0 } .
D. MNIST E XPERIMENT
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 ∈ R 64 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.
D. C OMPUTING C ORRECTION T ERM ON MOG AND MNIST E XPERIMENTS
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 η x H − 1 yy H yx ∇ x f :
Computing η x H yx ∇ x f by ﬁnite difference b := ∇ y f ( x , y ) − ∇ y f ( x − η x ∇ x f, y ) ; 2.
Assigning x ← x − η x ∇ x f such that the Hessian H below are evaluated at the updated x ; 3.
Solving linear system (cid:0) H
yy
+ λ I (cid:1)
∆ y
= H yy b using conjugate gradient to get an approximation of ∆ y
=
(cid:0)
H
yy
+ λ I (cid:1)
− 1 H yy b
≈ η x H − 1 yy H yx ∇ x f ; 4.
Adapting the damping coefﬁcient λ by computing reduction ratio
[Equation]
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 .0 .
{+9 λ if ρ > 0 .2 . 
+}
λ if ρ ≤λ otherwise
Setting ∆ y ← 0 if ρ ≤ 0 (essentially we don’t believe the approximation if ρ is negative).
When momentum or preconditioning is applied, we modify ∇ x f above with the momentum or preconditioned version.
To be speciﬁc, we apply momentum and preconditioning before the computation of the correction term, Here, we give an example of FR with momentum:
[Equation]
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.
E A DDITIONAL R ESULTS E. T HE R OLE OF P RECONDITIONING
[Figure]
[Equation]
o r
[Equation]
n s i t
[Equation]
[Figure]
[Equation]
[Figure]
[Equation] [Figure] [Equation] [Figure]
[Equation]
[Figure]
[Equation]
[Figure]
[Equation] [Figure] [Equation]
[Figure]
D i s c
r
i m i n a t
o r P
r
e
d i c t i o n
[Figure]
G r a d i e n t
[Figure]
o r m
[Figure]
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.
For fair comparison, we also tune the learning rate for vanilla FR and the optimal learning rate is 0 .
Our ﬁrst 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.
E. T HE R OLE OF M OMENTUM
In this subsection, we discuss the effect of momentum in our algorithm.
We ﬁrst consider the following quadratic problem:
[Equation]
[-y 
-][Table] [Table]
22 + [Table] + [Table]
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 .
The results are plotted in Fig.
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
[Figure]
e. γ = 0 . 8 ), GDA diverges even when using very large learning rate ratios.
[Figure]
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.
[Figure] we conduct experiments with momentum coefﬁcient γ ∈ { 0 . 8 , 0 . 9 } .
As shown in the gradient norm plots of Fig.
[Figure] FR with large positive momentum coefﬁcient 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.
E. S PECTRUM FOR GAN M ODEL
[Figure]
As we claimed in Section 6.2.1, all eigenvalues of H
xx − H xy H − 1 yy H yx are nonnegative while all eigenvalues of H yy are non-positive.
Here we plot all eigenvalues of them in log scale.
To be noted, we plot the eigenvalues for − H
yy for convenience.
As expected, the Hessian matrix for the discriminator is negative semi-deﬁnite while the Schur compliment is positive semi-deﬁnite.