Assumption 2.
The function f ( x , y ) has ⇢ -Lipschitz Hessian, i.e., there exists a constant ⇢ >such that
[Equation]
Assumption 3.
The function f ( x , y ) is µ -strongly-concave in y , i.e., there exists a constant [-ℓ > 
 such-]µ >such that f ( x , y )  f
[Equation]
any
[Equation]
and y , y
[Equation]
Assumption 4.
The function P ( x ) , max y 2 R dy f ( x , y ) satisﬁes P ⇤ , inf x 2 R dx P ( x ) > 1 .
Deﬁnition 1.
Under Assumption 1 and 3, we deﬁne the condition number of f ( x , y ) as  , ` /µ .
The assumptions of Lipschitz continuous gradient and strongly-concavity on f indicate that the primal function P ( x ) , max y 2 R dy f ( x , y ) is well-deﬁned and has Lipschitz continuous gradients as shown in Lemma 1.
Lemma 1 ([20, Lemma 4.3]) .
Suppose the objective function f satisﬁes Assumptions 1 and 3, then the primal function P ( x ) , max y 2 R dy f ( x , y ) has (  + 1) ` -Lipschitz continuous gradients.
Additionally, the function y ⇤ ( x ) = arg max y 2 R dy f ( x , y ) is well-deﬁned and  -Lipschitz.
We also have r P ( x ) = r x f ( x , y ⇤ ( x )) .
Now we give the deﬁnitions of " -FSP and ( " ,  ) -SSP as follows.
Deﬁnition 2.
Suppose the function f ( x , y ) satisﬁes Assumption 1 and 3, then we call x an " -FSP of
P ( x ) if kr P ( x ) k 2  " .
Deﬁnition 3.
Suppose the function f ( x , y ) satisﬁes Assumption 1, 2 and 3, then we call x is an ( " ,  ) -SSP of P ( x ) if kr P ( x ) k 2  " and r 2 P ( x ) ⌫   I .
The following two lemmas provide the closed form of r 2 P ( x ) and its Lipschitz continuity.
Lemma 2 ([32]) .
Suppose the function f ( x , y ) satisﬁes Assumption 1, 2 and 3.
We use the deﬁnition of y ⇤ ( x ) in Lemma 1, then it holds that r 2 P ( x ) =
H ( x , y ⇤ ( x )) .
Lemma 3.
Under assumptions of Lemma 2, we have
[Equation]
for any x and x 0 in R d x .
2.2 Local Optimality of Minimax Optimization
The Nash equilibrium is widely used in the study of convex-concave minimax optimization [38, 41], but it is intractable in general when the objective function f ( x , y ) is nonconvex in x or nonconcave in y .
For the general minimax problem, we introduce the local minimax point [17], which characterizes the optimality in two-player sequential games where players can only change their strategies locally.
Deﬁnition 4 ([17]) .
Given a differentiable function f ( x , y ) :
R d x ⇥ R d y !
R that is stronglyconcave in y , a point ( x ⇤ , y ⇤ ) 2 R d x ⇥ R d y is called a local minimax point of f , if there exists  0 > 0 and a function h satisfying h (  ) ! as  ! 0 , such that for any  2 (0 ,  0 ] , x 2 B ( x ⇤ , h (  )) and y 2 R d y , we have
[Equation]
Remark 1.
The deﬁnition of local minimax point for general nonconvex-nonconcave [17] only requires (3) holds for any y and y 0 in a neighbour of y ⇤ , while the constraint on y and y 0 is unnecessary in our setting since we assume that f ( x , y ) is strongly-concave in y .
The local minimax point enjoys the following property.
Lemma 4 ([17, Proposition 19]) .
Suppose f ( x , y ) is twice differentiable, then any point ( x ⇤ , y ⇤ ) satisfying r f ( x ⇤ , y ⇤ )
= 0 ,
r 2 yy f ( x ⇤ , y ⇤ )  0 and H ( x ⇤ , y ⇤ )  0 is a local minimax point of f ( x , y ) .
Based on Lemma 4, we introduce the strict-minimax condition on f which is an extension of strict-saddle condition for nonconvex minimization [3, 10, 11, 16, 34, 35].
Deﬁnition 5.
Under Assumption 1, 2 and 3, we say f ( x , y ) is ( ↵ ,  ,  ) -strict-minimax for some ↵ > 0 ,  > 0 and  > 0 if every (ˆ x , ˆ y ) 2 R d x ⇥ R d y satisﬁes at least one of the following three conditions: (a) kr f
(ˆ x , ˆ y ) k 2 > ↵ ; (b)  min ( H (ˆ x , ˆ y )) <
; (c) There exists a local minimax point ( x ⇤ , y ⇤ )
such that [Equation]
Note that if f is ( ↵ ,  ,  ) -strict-minimax and there exists a point ˆ x which is an ( " ,  ) -SSP of P ( x ) with sufﬁcient small " and  , then we can ﬁnd ˆ y ⇡ arg max y f
(ˆ x , y ) via running a ﬁrst-order algorithm to minimize  f
(ˆ x , · ) and obtain (ˆ x , ˆ y ) which is in a neighborhood of ( x ⇤ , y ⇤ ) .
In other words, under the strict-minimax condition, we can reduce the task of ﬁnding approximate local minimax point of f ( x , y ) to ﬁnding an approximate SSP of P ( x ) .
We will provide the formal statement in Section 3.2.
2.3 Accelerated Gradient Descent
Algorithm 1 AGD( h, y 0 , K, ⌘ , ✓ ) 1: ˜ y
= y2: for k = 0 , . . .
, K  1 do 3: y k +1 =
˜
y k  ⌘ r h (˜ y k ) 4: ˜
y k +1 =
y t +1 + ✓ ( y k +1  y k ) 5: end for 6: Output: y K
Nesterov’s accelerated gradient descent (AGD) is the optimal ﬁrst-order algorithm for convex optimization [25, 27], which is widely used in minimax optimization algorithms [21, 37].
We describe the details of AGD for smooth and strongly-convex functions in Algorithm 1, which has the following convergence rate.
Lemma 5 ([37, Lemma 2]) .
Running Algorithm 1 on a ` h -smooth and µ h -strongly-convex objective function h ( · ) with parameters ⌘ = 1 / ` h and ✓ = p  h  1 p  h +1 produces the output y K satisfying k y K
[Equation] where y ⇤ =
arg min y h
( y ) and  h = ` h /µ h .
2.4 Cubic Regularized Newton
Cubic regularized Newton (CRN) is a classic algorithm for nonconvex minimization [5, 6, 25, 26, 36].
It solves the nonconvex minimization problem min x g ( x ) via the following update rules
[Equation]
The CRN method could ﬁnd an  [Equation] SSP of g ( x ) with O  [Equation]
number of iterations, where ⇢ g is the Lipschitz continuous constant of the Hessian of g ( x ) .
Minimax Cubic Newton Algorithm
In this section, we propose our minimax cubic Newton algorithm and give its convergence results.
3.1 Minimax Cubic Newton Method
We present the details of Minimax Cubic Newton (MCN) method in Algorithm 2.
In each round, the
MCN algorithm performs following steps:
• Run AGD as presented in Algorithm 1 to estimate y t ⇡ y ⇤ ( x t ) =
arg max y f
( x t , y ) .
• Compute the inexact ﬁrst-order and second-order information of P at x t as r P ( x t ) ⇡ g
[Equation] = r x f ( x t , y t ) and r 2 P ( x t ) ⇡ H t
=
H
( x t , y t ) .
• Solve the following cubic regularized problem
[Equation]
1: Input: x 0 2 R d x , y  1 = 0 , T , { K t } Tt =0 , " .
2: for t = 0 , · · · T  1 do 3: y t =
AGD ⇣  f ( x t , · ) , y t  1 , K t , 1 ` , p   1 p  + ⌘ 4: g t = r x f ( x t , y t ) , H t
= H ( x t , y t ) 5: s ⇤ t =
arg min s 2 R dx ⇣ g > t s + 12 s > H t s + M 6 k s k⌘ 6: if k s ⇤ t k 2 p " /M then break 7: x t [-+
-]+1 = x t
+ s ⇤ t 8: end for 9: Output: ˆ x = x t + s ⇤ t
The expressions of g t and H t in the algorithm are inspired from Lemma 1 and 3.
The smoothness of r P ( x ) and r 2 P ( x ) allow the total complexity of AGD iteration of the algorithm has the desired upper bound.
Our theoretical analysis show the termination condition in
Line 7 of Algorithm 2 can be attained in no more than O (  1 . 5 p ⇢"  1 . 5 ) number of iterations.
We also show that a small k s ⇤ t k 2 will lead to a desired approximate second-order stationary point of P ( x ) .
Hence, using AGD to optimize f ( x t + s ⇤ t , y ) with respect to y generates an approximate local minimax point of f ( x , y ) .
3.2 Complexity Analysis for MCN
In this section, we let M = 4 p 2  3 ⇢ for MCN.
Our analysis for MCN algorithm contains three parts: 1.
We follow Tripuraneni et al.
[36]’s idea to show that our algorithm with sufﬁcient accurate gradient and Hessian estimator of P ( x ) requires no more than T
= O   1 .
5 p ⇢"  1 . rounds of iterations to achieve an
[Equation] SSP of P [Equation]
We prove the AGD step in line 3 requires at most ˜ O   2 p ⇢ [Equation] [Equation]
gradient calls in total.
The last part shows we can achieve an approximate local minimax point of f ( x , y ) from an  [Equation] ,  1 . 5 p ⇢
[Equation]  -second-order stationary point of P ( x ) under strict-saddle condition. Cubic Newton Iteration on P ( x ) The procedure of our Algorithm 2 can be regarded as applying cubic Newton method to minimize nonconvex function P ( x ) , but using inexact ﬁrst-order and secondorder information.
We consider the following conditions on the inexact gradient and Hessian, which will hold if we run AGD with enough number of iterations.
Assumption 5.
Suppose the estimators g t 2 R d x and H t 2 R d x ⇥ d x satisfy conditions kr P [Equation]
x t [Equation]  g t k 2  C [Equation]
and [Equation] The following lemma implies the analysis of MCN algorithm only needs to focus on the case of each k s ⇤ t k 2 is large, otherwise we have already ﬁnd x t +1 which a desired approximate SSP of P ( x ) .
Lemma 6.
Under Assumption 5 with C g = 1 / 192 and C H = 1 / 48 , if x t +1 from Algorithm 2 is not an  " , p M "  -SSP of P ( x ) , we have k s ⇤ t k 2 p " /M .
By Lemma 6, we can show that MCN with sufﬁcient accurate gradient and Hessian estimators can ﬁnd an [Equation] P [Equation]
x )
[Equation] T = O
[Equation]  number of iterations as follows.
Theorem 1.
Under Assumption 1-4, we run Algorithm 2 with T =
⌃
[Equation] 1 ; and further suppose K t is sufﬁcient large so that results g t and H t satisfy Assumption 5 with
C g = 1 / 192 and C H = 1 / 48 .
Then the output ˆ x is an  " , p M "  -SSP of P ( x ) .
Total Complexity of AGD Note that MCN (Algorithm 2) applies AGD to maximize f ( x t , · ) by using y t  1 as initialization at the t -th round.
With such initialization, the following theorem provides the upper bound of total number of gradient calls required by AGD and guarantees that g t and H t in the MCN algorithm satisfy Assumption 5.
Theorem 2.
Under Assumption 1-4, we run Algorithm 2 with K 0 =
⌃
[Equation] ⌥ and K t = ⌃ 2 p  log  [Equation]
[Equation]   s ⇤ t  ⌥ for t  1 , where ˜ " =
min  C g " / ` , C H p M " / ⇢ and s 0 = 0 .
Then all g t and H t satisfy the condition of Assumption 5.
We also have
T
[Equation]
1: Input: x 0 2 R d x , y  1 = 0 , T , { K t } Tt =0 , " 2: c k = 2 p ` µ ✓ p µ/ `  1 p µ/ ` + ◆ k 3: for t = 0 , · · · do 4: y t =
AGD   f ( x t , · ) , y t  1 , K t , 1 ` , p   1 p  +  5: g t = r x f ( x t , y t ) 6:
Z t =  2 {+`  µ  r 
+}
yy f ( x t , y t ) + ` + µ 2 I  7:
Compute H t as equation (5) 8: ( s t ,  t )=
Cubic-Solver ( g t , H t ,  , K ( " ,  0 ))
9: x t +1 = x
t + s t 10: if  t > p " 3 /M
then 11: ˆ s = Final-Cubic-Solver ( g t , H t , " ) 12: x t +1 = x t
+ ˆ s 13: break 14: end if 15: end for 16:
Output: ˆ x = x t +
Algorithm
1: Input: g , H ,  , K ( " ,  0 ) 2: if k g k 2  L 2 /M then 3:
R C =  g >
Hg M k g k+ vuut g > Hg
M k g
{+k 22 ! +
+}
k g k 2 M 4: ˆ s =  R C g / k g k5: else 6: s 0 = 0 , ⌘ = 1 / (20 L ) 7:
˜ g = g +  ⇣ for ⇣ ⇠ Uniform( S d  1 ) 8: for k = 0 , · · · , K ( " ,  0 ) do 9: s k +
=
s k  ⌘  ˜ g
+ Hs k
+ M 2 k s k k
s k  10: end for 11: ˆ s = s K ( " ,  0 ) 12: end if 13: Output: ˆ s and  = g > ˆ s + 12 ˆ s > H ˆ
s + M [-
 ∥-]6 k ˆ s [-∥ 
-]k
Combining Theorem 1 and Theorem 2, we can obtain the total number of gradient oracle calls,
Hessian (inverse) oracle calls and exact cubic sub-problem solver calls as follows.
Corollary 1.
Under Assumption 1-4, running Algorithm 2 with T = ⌃ 192( P ( x 0 )  P ⇤ )
p M " 0 1 . [Equation] ⌥ +1 ,
K 0 = [Equation] and [Equation]
[Equation]  ⌥ for t  1 , where ˜ " [Equation]
= min  C g " 0 / ` , C H p M " 0 / ⇢ , s
= 0 and " 0 =2  2 . 5 " , then the output ˆ x is an  " ,  1 . 5 p ⇢"  -SSP of P ( x ) and the number of gradient oracle calls is at most ˜ O   2 p ⇢"  1 . .
The total number of
Hessian (inverse) oracle calls and exact cubic sub-problem solver calls is at most O  p ⇢ 1 . 5 "  1 . .
Note that MCN method needs to construct the Hessian estimator H t
= H ( x t , y t ) and solves the cubic regularized sub-problem (4) in each round.
Constructing H t requires calling the second-order oracle at ( x t , y t ) and taking O  d 3 y + d x d 2 y + d 2 x d y  ﬂops for matrix multiplication and inversion.
Solving sub-problem (4) requires O  d 3 x  ﬂops for matrix factorization or inversion [5, 6].
Hence, besides the gradient calls from AGD step, MCN requires O [Equation] time complexity in each round and its space complexity is O
[Equation] Approximate Local Minimax Point Under the strict-minimax condition, we can ﬁnd an approximate local minimax point by performing an additional AGD procedure on the output of MCN.
Corollary 2.
Suppose f ( x , y ) is ( ↵ ,  ,  ) -strict-minimax and satisﬁes Assumption 1-4.
Let ˆ x be the output of running Algorithm 2 with the setting of Corollary 1 and " = min  [Equation] 
[Equation]
⇢ ) .
Let ˆ y =
AGD [Equation]  where t corresponds to the last iteration of Algorithmsuch that ˆ x = x t + s ⇤ t and ˆ K = p  log
[Equation]
.
Then there exists a local minimax point ( x ⇤ , y ⇤ ) of f ( x , y ) such that k x ⇤  ˆ x {+k 
+} + k y ⇤  ˆ y k 22   2 .
Inexact Minimax Cubic Newton Algorithm
In this section, we proposed an efﬁcient algorithm called inexact minimax cubic Newton (IMCN), which avoids any operation related to the second-order oracle and only requires ˜ O   1 . 5 `"  Hessian-vector product calls and ˜ O   2 p ⇢"  1 . gradient calls in total to ﬁnd  " ,
 1 . 5 p ⇢"  -SSP of P ( x ) .
Since the Hessian-vector products can be computed as fast as gradients [28, 31], IMCN is much more efﬁcient than MCN in high-dimensional cases.
1: Input: g , H , " 2: s 0 = 0 , g
= g , ⌘ = 1 / (20 L ) 3: for t = 0 , . . .
do 4: if k g t k 2  " / 2 then break 5: s t {++
+} =
s t  ⌘ g t 6: g t +
= g + Hs t +1 + M
k s t[-+
-]
+1 k 2 s t + 7: end for 8: Output: s t
We present the details of IMCN in Algorithm 3.
Unlike MCN which solves problem (4) exactly, IMCN uses gradient-based cubic sub-problem solver (Algorithm 4) [4] to compute
[Equation]
If the condition in line 10 of Algorithm 3 holds, the point x t + s ⇤ t should be a desired approximate secondorder stationary point.
Due to s ⇤ t is hard to obtain, we introduce additional gradient descent steps (Algorithm 5) to approximate it by ˆ s and use x t
+ ˆ s as the ﬁnal output.
The design and the convergence analysis of IMCN is more challenging than existing inexact cubic
Newton algorithms for minimization problems [18, 36] since the Hessian estimator in IMCN has a more complicated structure.
To address this issue, we approximate the Hessian r 2 P ( x t ) by H t as
[Equation]
where C t =
[Equation]
P
[Equation]
T k ( Z [Equation]
) and Z t = [Equation]  [Equation]
[Equation] I  . Here T k ( · ) is the matrix Chebyshev polynomials (shown in Section 4.1) leading to C t ⇡   r 2 yy ( x t , y t )   1 .
Note that we never construct matrix H t explicitly in implementation because all operations related to H t can be reduced to compute Hessian-vector products, which avoid any second-order oracle calls or matrix factorization/inversion.
Then we provide the convergence analysis for the IMCN algorithm.
Throughout this section, we let L = {+
 `+} and M = 4 p 2  3 ⇢ be the Lipschitz continuous constants of r P ( x ) and r 2 P ( x ) .
We suppose "  L 2 /M , otherwise, the second-order condition r 2 P ( x ) ⌫ p M " I always holds and we only need to use gradient methods [20, 21] to ﬁnd ﬁrst-order stationary point.
4.1 Approximating Hessian by Matrix Chebyshev Polynomials
We ﬁrst show the error bound of matrix inverse approximation via matrix Chebyshev polynomials.
Lemma 7.
Suppose symmetric matrix X 2 R d ⇥ d satisﬁes µ {+
+}
I  X  ` 0 I with 0 < µ 0  ` 0 < 1 , then we have [-(cid:13)(cid:13) X − 1 − (cid:0) c 0 
-]
[Equation]
[Equation]
p
[Equation]
)  K 0 where
Z [Equation] = [Equation]
p [Equation] k , and T k ( · ) are matrix Chebyshev polynomials with T [-
-]0 ( Z 0 )
=
I , T 1 ( Z 0 )
=
Z 0 and T k ( Z 0 )
= 2 Z {+
+} T k  1 ( Z 0 )
T k  2 ( Z 0 ) for k  2 .
Based on Lemma 7, we can bound the approximation error of the Hessian estimator H t as follows.
Lemma 8.
Using the notation of Algorithm 3, we have
[Equation]
Lemma 8 means using AGD with K t
= O ( p  log( ⇢ / " H )) =
˜ O ( p  ) 2 and the number of terms for Chebyshev polynomials with K {+
+}
=
O ( p  log( ` / " H )) =
˜ O ( p  ) could achieve H t with  r 2 P ( x t )  H t  2  " H for any " H > 0 .
In the implementation of IMCN, all operations related to H t can be viewed as computing Hessianvector products.
Actually, we can obtain H t u 0 with O ( K 0 )
=
˜ O ( p  ) Hessian-vector calls for any u 0 2 R d x , which avoids O  d 2 x + d 2 y  space to keep Hessian matrices.
The detailed implementation is presented in Appendix E.
4.2 Complexity Analysis for IMCN
The IMCN method calls a gradient-based sub-problem solver (Algorithm 4) to optimize the following cubic regularized problem [4, 36] in each iteration
[Equation]
It requires at most K ( " ,  0 )
=
O
[Equation]
M
[Equation]
number of iterations to achieve an approximate solution with enough accuracy.
The detailed analysis for the complexity of Algorithm 4 is deferred to appendix D.
Then we bound the total number of iterations for Algorithm 3.
Theorem 3.
Running Algorithm 3 with C  = 1 / 4 ,  0 =  /T , T =
d 626( P ( x 0 )  P ⇤ ) p M "  1 .
5 e and sufﬁcient large K t and K 0 such that Assumption 5 holds with C g = 1 / 240 and C H = 1 / 200 .
Then the condition  t  p " 3 /M in line 11 must hold in no more than T
=
O   1 .
5 p ⇢"  1 . iterations; and the output ˆ x is an ( " ,
2  1 . 5 p ⇢" ) -SSP with probability 1   .
We also bound the number of gradient calls from AGD procedure in Algorithm 3 as follows.
Theorem 4.
Under the setting of Theorem 3, if we run Algorithm 3 with
K 0 =
[Equation]
and
[Equation]
[Equation] where ˜ " = min
[Equation]
C H p M " , " H L / (6 ⇢ 2 ) and s 0 = 0 , then it holds that kr P ( x t [Equation]
g
[Equation]  C g " ,  [Equation]
[Equation]
M
[Equation]
L and
T X t =
K
[Equation]
Note that the value of K 0 =
˜ O ( p  ) corresponds to the number of Hessian vector calls for each iteration of cubic sub-problem solver (Algorithm 4 and 5).
Combining Theorem 3, Theorem 4 and the value of K ( " ,  0 ) , we obtain the main result for Algorithm 3 as follows.
Corollary 3.
Under Assumption 1-4, if we run Algorithm 3 with C  = 1 / 4 , {+ 
+} =
/T ,
K 0 = & p  +1log
[Equation] and K [Equation] [Equation]
⇣
[Equation] l [Equation] ⇣ p
[Equation]  ˜ [Equation] +  k s t
[Equation]
k
[Equation]
⌘m
[Equation]
t where T =
⌃ 626( P ( x 0 )  P ⇤ ) p M " 0 1 . ⌥ , C g = 1 / 240 , C H
= 1 / 200 , s
= 0 , ˜ {+" 
+}
= " / 4 and ˜ "
= min  C g " / (4 ` ) , min
C H p M " , 3 L (12 ⇢ 2 ) , then the output ˆ x is an  " ,  1 . 5 p ⇢"  -secondorder stationary point of P ( x ) with probability 1   and the number of gradient calls is at most ˜
O   2 p ⇢"  1 . .
The number of Hessian-vector product calls is at most O
[Equation]
Following the analysis of Corollary 2, we can also achieve an approximate local minimax point by running AGD based on the ˆ x obtained from Algorithm 3.
Experiments
In this section, we conduct empirical studies for our methods against the classical GDA algorithm [20] on both synthetic problem and real-world application.
5.1 Synthetic Minimax Problem
We construct the following nonconvex-strongly-concave minimax problem:
[Equation]
where x = [ x 1 , x 2 , x 3 ] > , y =
[ y 1 , y 2 ] > and w ( · ) is the W-shaped scalar function [36] whose exact form is shown in Appendix G.1.
It is easy to verify that the problem has an strict saddle point at ( x 0 , y 0 ) =
([0 , 0 , 0] > , [0 , 0] > ) .
[Figure]
We conduct experiments on problem (7) with two different initial points ( x 1 , y 1 ) =
[10  3 , 10  3 , 10  3 ] > , [0 , 0] >  and ( x 2 , y 2 ) =
[0 , 0 , 1] > , [0 , 0] >  .
Notice that problem (7) has an strict saddle point at ( x 0 , y 0 )
=
([0 , 0 , 0] > , [0 , 0] > ) .
The initial point ( x 1 , y 1 ) is close to ( x 0 , y 0 ) and ( x 2 , y 2 ) is far from ( x 0 , y 0 ) .
We compare the proposed algorithm MCN with GDA.
The learning rate of GDA and AGD step in MCN is selected from  c · 10  i : c 2 { 1 , 5 } , i 2 { 1 , 2 , 3 } .
For MCN method, we choose M = 10 .
We compare the running time against P ( x )  P ⇤ , kr P ( x ) k 2 and  min ( r 2 P ( x )) for two algorithms and plot the results in Figure 1.
From the curves corresponding to initial point ( x 2 , y 2 ) , we observe that both
MCN and GDA converge to the minimum when the initial point is far from the strict saddle point, but MCN converges much faster than GDA.
When the initial point is close to the strict saddle point,
Figure 4(b) shows that the GDA algorithm gets stuck at the strict saddle point since its Hessian minimum eigenvalue are always negative.
However, our MCN algorithm can reach the points which have positive Hessian minimum eigenvalues.
5.2 Domain Adaptation
The Domain-Adversarial Neural Network (DANN) [9] is a classic method to domain adaptation.
Suppose the source domain dataset is S
= { ( a Si , b Si ) } N S i =1 where a S i is the feature vector of the i -th sample and b S i is the corresponding label.
The target domain dataset T = { a T i } N T i =1 only contains features.
Then DANN aims to solve the following nonconvex-strongly-concave minimax problem
[Equation]
where L 1 ( x 1 , x 2 )
= 1 N S
P N S i =1 l ( x 2 ;  ( x 1 ; a S i ) , b S i ) is the loss of supervised learning and
L
[Equation]
=
[Equation]
N
[Equation]
is the domain classiﬁcation loss.
Here  is a single-layer neural network of size (28 ⇥ 28) ⇥ 200 with parameter x 1 and l is a two-layer neural network of size 200 ⇥ 20 ⇥ 10 with parameter x 2 , followed
[Figure]
by a cross entropy loss.
We choose the sigmoid function as the activation function for them.
With the commonly used logistic loss for L 2 , we let h ( y ; z )
=
1 / (1 + exp (  y > z )) , D S ( z ) = 1  log( z ) and D T ( z ) =
{+log(
 +} z ) .
Since the dimension of the minimax problem is quite large, we implement the IMCN algorithm instead of the MCN algorithm for efﬁciency.
We compare IMCN with GDA on the domain adaptation problem between two different datasets: MNIST [19] and MNIST-m [9].
Since we do not know the close form of P ( x ) , we estimate the value of P ( x ) =
max y f ( x , y ) by AGD procedure.
More details about our experimental setup can be found in Appendix G.2.
We compare IMCN and GDA algorithms via running time and oracle calls and show the results in
Figure 2.
We run the experiments for ﬁve times with different random initialization and report the average results.
The oracle calls of GDA only contains gradient while the oracle calls of IMCN contains both gradient and Hessian-vector product.
Based on Figure 2, we observe that IMCN signiﬁcantly outperforms GDA in both time and oracle comparison.
Notice that IMCN requires to call much more gradient/Hessian-vector oracles on y than the gradient oracles on x .
These results verify our convergence analysis and show the advantage of proposed algorithm.
Conclusions and Future Work
In this paper, we study second-order optimization methods for nonconvex-strongly-concave minimax problems.
We have proposed a novel algorithm so-called minimax cubic Newton (MCN) which could ﬁnd an ( " ,  1 . 5 p ⇢" ) -SSP of the primal function with O (  1 . 5 p ⇢"  1 . 5 ) second-order oracle calls and ˜ O (  2 p ⇢"  1 . 5 ) gradient oracle calls.
We also provide an efﬁcient algorithm for high dimensional problem, which avoids accessing second-order oracle and contains ˜ O (  1 . 5 `"  2 ) Hessian-vector oracle calls and ˜ O (  2 p ⇢"  1 . 5 ) gradient oracle calls.
To best of our knowledge, this paper ﬁrst achieves non-asymptotic convergence result for ﬁnding SSP of minimax problem without convexconcave assumption.
There are several interesting problems for future work: (a) The proposed algorithms and analysis require the strongly convexity assumption on y .
We would like to study how to ﬁnd SSPs for general nonconvex-concave minimax problems.
(b) The upper complexity bounds of proposed algorithms look not optimal.
It is possible to apply the acceleration techniques to establish more efﬁcient algorithms for our task.
(c) The implementations of proposed IMCN still require accessing
the
Hessian-vector oracle.
It is interesting to investigate how to ﬁnd SSPs of our minimax problem by pure ﬁrst-order algorithms.
(d) This paper does not consider the speciﬁc structure of the objective function.
However, many machine learning models can be formulated as minimax problems where the objective functions have ﬁnite-sum or expectation form.
Designing efﬁcient stochastic algorithms for such formulations is an interesting problem to the machine learning community.
Acknowledgements
Luo Luo is supported by National Natural Science Foundation of China (No. 62206058) and Shanghai Sailing Program (22YF1402900). Cheng Chen is supported by Singapore Ministry of Education (AcRF) Tier 1 grant RG75/21.