G RAM -G AUSS -N EWTON M ETHOD : L EARNING O VERPARAMETERIZED N EURAL N ETWORKS FOR R EGRESSION P ROBLEMS
Anonymous authors
Paper under double-blind review
A BSTRACT
First-order methods such as stochastic gradient descent (SGD) are currently the standard algorithm for training deep neural networks.
Second-order methods, despite their better convergence rate, are rarely used in practice due to the prohibitive computational cost in calculating the second-order information.
In this paper, we propose a novel Gram-Gauss-Newton (GGN) algorithm to train deep neural networks for regression problems with square loss.
Our method draws inspiration from the connection between neural network optimization and kernel regression of neural tangent kernel (NTK).
Different from typical second-order methods that have heavy computational cost in each iteration, GGN only has minor overhead compared to ﬁrst-order methods such as SGD.
We also give theoretical results to show that for sufﬁciently wide neural networks, the convergence rate of
GGN is quadratic .
Furthermore, we provide convergence guarantee for mini-batch
GGN algorithm, which is, to our knowledge, the ﬁrst convergence result for the mini-batch version of a second-order method on overparameterized neural networks.
Preliminary experiments on regression tasks demonstrate that for training standard networks, our GGN algorithm converges much faster and achieves better performance than SGD.
I NTRODUCTION
First-order methods such as Stochastic Gradient Descent (SGD) are currently the standard choice for training deep neural networks.
The merit of ﬁrst-order methods is obvious: they only calculate the gradient and therefore are computationally efﬁcient.
In addition to better computational efﬁciency,
SGD has even more advantages among the ﬁrst-order methods.
At each iteration, SGD computes the gradient only on a mini-batch instead of all training data.
Such randomness introduced by sampling the mini-batch can lead to better generalization (Hardt et al., 2015; Keskar et al., 2016; Masters &
Luschi, 2018; Mou et al., 2017; Zhu et al., 2018) and better convergence (Ge et al., 2015; Jin et al., 2017a;b), which is crucial when the function class is highly overparameterized deep neural networks.
Recently there is a huge body of works trying to develop more efﬁcient ﬁrst-order methods beyond
SGD (Duchi et al., 2011; Kingma & Ba, 2014; Luo et al., 2019; Liu et al., 2019).
Second-order methods, despite their better convergence rate, are rarely used to train deep neural networks.
At each iteration, the algorithm has to compute second order information, for example, the Hessian or its approximation, which is typically an m by m matrix where m is the number of parameters of the neural network.
Moreover, the algorithm needs to compute the inverse of this matrix.
The computational cost is prohibitive and usually it is not even possible to store such a matrix.
Recently, there is a series of works (Du et al., 2018b;a; Zou et al., 2018; Allen-Zhu et al., 2018a;
Oymak & Soltanolkotabi, 2018; Arora et al., 2019b;a; Cao & Gu, 2019; Zou & Gu, 2019) considering the optimization of neural networks based on the idea of neural tangent kernel (NTK)
(Jacot et al., 2018).
Roughly speaking, the idea of NTK is to linearly approximate the output of a network w.r.t.
the parameters at a local region, thus resulting in a kernel feature map, which is the gradient of the output w.r.t.
the parameters.
Jacot et al.
(2018) shows that when the width of the network tends to inﬁnity, the NTK tends to be unchanged during gradient ﬂow since the network only needs o (1) change (goes to zero as the width tends to inﬁnity) of parameter to ﬁt the data, so the change of kernel is also o (1) .
As for ﬁnite-width networks, however, the NTK changes and previous works (Allen-Zhu et al., 2018b; Arora et al., 2019a) show that for sufﬁciently wide neural networks the optimization dynamic of GD/SGD is equivalent to that of using GD/SGD to solve an NTK kernel regression problem where the kernel is slowly evolving (see Lemma 1 in Section 2 for a precise description).
A natural question then arises:
Can we gain acceleration by directly solving kernel regression w.r.t.
the NTK at each step?
In this paper, we give a positive answer to this question and reveal the connection between NTK regression and Gauss-Newton method.
We propose a novel optimization method – the Gram-GaussNewton (GGN) method.
Instead of doing gradient descent, GGN solves the kernel regression w.r.t.
the NTK at each step of the optimization.
Following this idea, we theoretically prove that for overparameterized networks, GGN enjoys quadratic convergence compared to the linear rate of gradient descent.
Besides theoretical fast convergence rate, GGN is also very efﬁcient in practice.
In fact, GGN is implicitly a reformulation of the Gauss-Newton method (see Section 3.1 for details) which is a classic second-order algorithm often used for solving nonlinear regression problems with square loss.
In the
Gauss-Newton method, one uses J (cid:62) J as an approximation of the Hessian (see Section 2 for a formal description) where J is the Jacobian matrix.
However, the original Gauss-Newton method faces challenges when used for training deep neural networks.
Most seriously, the size of the approximate
Hessian J (cid:62) J is m by m , where m is the number of parameters of the neural network.
Moreover, for overparameterized neural networks, J (cid:62) J is not invertible, which may make the algorithm intractable for training commonly-used neural networks.
GGN bypasses the difﬁculty stated above as follows.
Instead of using J (cid:62) J as approximate Hessian and applying Newton-type method, each step of GGN only involves the Gram matrix JJ (cid:62) whose size is n by n where n is the number of data.
Furthermore, as already mentioned, to get better generalization performance, it is crucial to use mini-batch to introduce sampling noise when calculating derivatives.
Therefore, like SGD, we also use mini-batch in GGN.
In this case, the size of the
Gram matrix further reduces to b by b , where b is the batch size.
Though conventional wisdom may suggest that applying mini-batch scheme to second-order methods will introduce biased estimation of the accelerated gradient direction, we give the ﬁrst convergence result for mini-batch second-order method on overparameterized networks.
Regarding computational complexity, we show that at each iteration, the overhead of GGN is small compared to SGD: the extra computation of GGN is mainly the matrix product JJ (cid:62) and the inverse of this matrix whose size is small for a mini-batch.
Detailed analyses can be found in Section 3.3.
We next conduct experiments on two regression tasks to study the effectiveness of the GGN algorithm.
We demonstrate that in these two real applications, using a practical neural network (e.g., ResNet-32) with standard width, our proposed GGN algorithm can converge faster and achieve better performance than several baseline algorithms.
1. R ELATED W ORKS
Despite the prevalence of ﬁrst-order methods for training deep neural networks, there have been continuing efforts in developing practical second-order methods (Becker et al., 1988; Pascanu &
Bengio, 2013).
We summarize some of these works below.
The main approach for these methods is to develop delicate approximations of the second-order information matrix so that the update direction can be computed as efﬁciently as possible.
For example, Botev et al.
(2017) proposed a recursive block-diagonal approximation of the Hessian.
The blocks are Kronecker factored and can be efﬁciently computed and inverted.
Grosse and Martens in a series of works developed the K-FAC method (Martens & Grosse, 2015; Grosse & Martens, 2016).
The key idea is a Kronecker-factored approximation of the Fisher information matrix, which is used as the second-order matrix in natural gradient methods.
These works received considerable attention and have been further improved (Wu et al., 2017;
George et al., 2018; Martens et al., 2018).
Bernacchia et al.
(2018) derived an exact expression of the natural gradient update, but only works for linear networks.
Different from all these works, our GGN algorithm does not try to approximate the second-order matrix whose size is inevitably huge.
Instead, we present an easy-to-compute solution of the updating direction, reducing the computational cost signiﬁcantly.
One exceptional concurrent work Ren & Goldfarb (2019) also aims to use the exact Gauss-Newton update.
They focus on reducing the complexity of inverting approximate Hessian by Sherman-Morrison-Woodbury
Formula and require subtle implementation tricks to use backpropagation.
In contrast, GGN has simpler update rule and better guarantee for neural networks.
In a concurrent and independent work, Zhang et al. (2019a) showed that natural gradient method and K-FAC have a linear convergence rate for sufﬁciently wide networks in full-batch setting.
In contrast, our method enjoys a higher-order (quadratic) convergence rate guarantee for overparameterized networks, and we focus on developing a practical and theoretically sound optimization method.
We also reveal the relation between our method and NTK kernel regression, so using results based on NTK (Arora et al., 2019b), one can easily give generalization guarantee of our method. Another independent work (Achiam et al., 2019) proposed a preconditioned Q-learning algorithm which has similar form of our update rule. Unlike the methods considered in Zhang et al. (2019a); Achiam et al.
(2019) which contain the learning rate that needed to be tuned, our derivation of GGN does not introduce a learning rate term (or understood as suggesting that the learning rate can be ﬁxed to beto get good performance which is veriﬁed in Figure 2 (c)).
N EURAL T ANGENT K ERNEL AND THE C LASSIC G AUSS -N EWTON M ETHOD FOR N ONLINEAR L EAST S QUARES R EGRESSION
Nonlinear least squares regression problem is a general machine learning problem.
Given data pairs { x i , y i } ni =1 and a class of nonlinear functions f , e.g. neural networks, parameterized by w , the nonlinear least squares regression aims to solve the optimization problem
[Equation]
In the seminal work (Jacot et al., 2018), the authors consider the case when f is a neural network with inﬁnite width.
They showed that optimization on this problem using gradient ﬂow involves a special kernel which is called neural tangent kernel (NTK).
The follow-up works further extended the relation between optimization and NTK which can be concluded in the following lemma:
Lemma 1 (Lemma 3.1 in Arora et al. (2019a), see also Dou & Liang (2019); Mei et al.
Consider optimizing problem (1) by gradient descent with inﬁnitesimally small learning rate: d w t d t = −∇ L ( w t ) .
where w t is the parameters at time t .
Let f t
=
( f ( w t , x i ))
ni =1 ∈ R n be the network outputs on all x
i ’s at time t , and y =
( y i ) ni
=1 be the desired outputs.
Then f t follows the following evolution:
[Equation]
where G t is an n × n positive semideﬁnite matrix, i.e. the Gram matrix w.r.t.
the NTK at time t , whose ( i, j ) -th entry is (cid:104)∇ w f ( w t , x i ) , ∇ w f ( w t , x j ) (cid:105) .
The key idea of Jacot et al.
(2018) and its extensions (Du et al., 2018b;a; Zou et al., 2018;
Allen-Zhu et al., 2018a; Oymak & Soltanolkotabi, 2018; Lee et al., 2019; Yang, 2019; Arora et al., 2019b;a;
Cao & Gu, 2019; Zou & Gu, 2019) is that when the network is sufﬁciently wide, the Gram matrix at initialization G 0 is close to a ﬁxed positive deﬁnite matrix deﬁned by the inﬁnite-width kernel and
G t is close to G 0 during training for all t .
Under this situation, G t remains invertible, and the above dynamics is then identical to the dynamics of solving kernel regression with gradient ﬂow w.r.t.
the current kernel at time t .
In fact, Arora et al. (2019a) rigorously proves that a fully-trained sufﬁciently wide ReLU neural network is equivalent to the kernel regression predictor.
As pointed out in Chizat & Bach (2018), the idea of NTK can be summarized as a linear approximation using ﬁrst order Taylor expansion.
We give an example of this idea on the NTK at initialization:
[Equation]
where ∇ w f ( w 0 , x ) can then be viewed as an explicit expression of feature map at x , w − w 0 is the parameter in reproducing kernel Hilbert space (RKHS) induced by NTK and f ( w , x i )
− f ( w 0 , x i ) the target value.
The idea of linear approximation is also used in the classic Gauss-Newton method (Golub, 1965) to obtain an acceleration algorithm for solving nonlinear least squares problem (1).
Concretely, at iteration t , Gauss-Newton method takes the following ﬁrst-order approximation:
[Equation]
where w t stands for the parameter at iteration t .
We note that this is also the linear expansion for deriving NTK at time t .
According to Eq.
(1) and (4), to update the parameter, one can instead solve the following problem.
[Equation]
where f t , y have the same meaning as in Lemma 1, and J t = ( ∇ w f ( w t , x 1 ) , · · · , ∇ w f ( w t , x n ))
(cid:62) ∈ R n × m is the Jacobian matrix.
A necessary and sufﬁcient condition for w to be the solution of Eq.
(5) is
[Equation]
Below we will denote H t :=
J (cid:62) t J t ∈ R m × m .
For under-parameterized model (i.e., the number of parameters m is less than the number of data n ), H t is invertible, and the update rule is
[Equation]
This can also be viewed as an approximate Newton’s method using H t =
J (cid:62) t J t to approximate the
Hessian matrix.
In fact, the exact Hessian matrix is
[Equation]
In the case when f is only mildly nonlinear w.r.t.
w at data point x i ’s, ∇ 2 w f ( w t , x i ) ≈ 0 , and H t is close to the real Hessian.
In this situation, the behavior of the Gauss-Newton method is similar to that of Newton’s method, and thus can achieve a superlinear convergence rate (Golub, 1965).
T HE G RAM -G AUSS -N EWTON M ETHOD
The classic second-order methods using approximate Hessian such as Gauss-Newton method described in the previous section face obvious difﬁculties dealing with the intractable approximate
Hessian matrix when the regression model is an overparameterized neural network.
In Section 3.1, we develop a Gram-Gauss-Newton (GGN) method which is inspired by NTK kernel regression and does not require the computation of the approximate Hessian.
In Section 3.2, we show that for sufﬁciently wide neural networks, GGN has quadratic convergence rate.
In Section 3.3, we show that the additional computational cost (per iteration) of GGN compared to SGD is small.
3. T HE G RAM -G AUSS -N EWTON M ETHOD FOR O VERPARAMETERIZED N EURAL N ETWORKS
We now describe our GGN method to learn overparameterized neural networks for regression problems.
As mentioned in the previous sections, for sufﬁciently wide networks, using gradient descent for solving the regression problem (1) has similar dynamics as using gradient descent for solving NTK kernel regression (Lemma 1) w.r.t.
NTK at each step.
However, one can also solve the kernel regression problem w.r.t.
the NTK at each step immediately using the explicit formula of kernel regression.
By explicitly solving instead of using gradient descent to solve NTK kernel regression, one can expect the optimization to get accelerated.
We propose our Gram-Gauss-Newton (GGN) method to directly solve the NTK kernel regression with Gram matrix G t at each time step t .
Note that the feature map of NTK at time t , based on the approximation in Eq.
(4), can be expressed as x (cid:55)→ ∇ w f ( w t , x ) , and the linear parameters in RKHS are w − w t , also the target is f ( w , x i ) − f ( w t , x i ) .
Therefore, the kernel (ridgeless) regression solution (Mohri et al., 2018; Liang & Rakhlin, 2018) of J t,S ( w − w t ) = ( f ( w , x i ) − f ( w t , x i )) w.r.t. ( w − w t ) gives the update
[Equation]
where J t,S is the matrix of features at iteration t computed on the training data set S which is equal to the Jacobian , f t,S and y S are the vectorized outputs of neural network and the corresponding targets on S respectively, and
[Equation]
One may wonder what is the relation between our derivation from NTK kernel regression and the
Gauss-Newton method.
We point out that for overparameterized models, there are inﬁnitely many solutions of Eq.
(5) but our update rule (9) essentially uses the minimum norm solution.
In other words, the GGN update rule re-derives the Gauss-Newton method with the minimum norm solution.
This somewhat surprising connection is due to the fact that in kernel learning, people usually choose a kernel with powerful expressivity, i.e. the dimension of feature space is large or even inﬁnite.
However, by the representer theorem (Mohri et al., 2018), the solution of kernel (ridgeless) regression lies in the n -dimensional subspace of RKHS and minimizes the RKHS norm.
We refer the readers to
Chapter 11 of Mohri et al.
(2018) for details.
As mentioned in Section 1, the design of learning algorithms should consider not only optimization but also generalization.
It has been shown that using mini-batch instead of full batch to compute derivatives is crucial for the learned model to have good generalization ability (Hardt et al., 2015;
Keskar et al., 2016; Masters & Luschi, 2018; Mou et al., 2017; Zhu et al., 2018).
Therefore, we propose a mini-batch version of GGN.
The update rule is the following:
[Equation]
where B t is the mini-batch used at iteration t , J t,B t and G t,B t are the Jacobian and the Gram matrix computed using the data of B t respectively, and f t,B t , y B t are the vectorized outputs and the corresponding targets on B t respectively.
G t,B t =
J t,B t J (cid:62) t,B t is a very small matrix when using a typical batch size.
One difference between Eq.
(10) and Eq.
(7) is that our update rule only requires to compute the
Gram matrix G t,B t and its inverse.
Note that the size of G t,B t is equal to the size of the mini-batch and is typically very small.
So this also greatly reduces the computational cost.
Using the idea of kernel ridge regression (which can also be viewed as Levenberg-Marquardt extension (Levenberg, 1944) of Gauss-Newton method), we introduce the following variant of GGN:
[Equation]
where λ > 0 is another hyper-parameter controlling the learning process.
Our algorithm is formally described in Algorithm 1.
Algorithm 1 (Mini-batch) Gram-Gauss-Newton Method
3. C ONVERGENCE A NALYSIS FOR O VERPARAMETERIZED N EURAL N ETWORKS
In this subsection, we show that for two-layer neural networks, if the width is sufﬁciently large, then: (1) Full-batch GGN converges with quadratic convergence rate.
(2) Mini-batch GGN converges linearly.
(For clarity, here we only present a proof for two-layer neural networks, but we believe that it is not hard for the conclusion to be extended to deep neural networks using the techniques developed in Du et al.
(2018a);
Zou & Gu (2019)).
As we explained through the lens of NTK, the result is a consequence of the fact that for wide enough neural networks, if the weights are initialized according to a suitable probability distribution, then with high probability the output of the network is close to a linear function w.r.t.
the parameters (but nonlinear w.r.t.
the input of the network) in a neighborhood containing the initialization point and a global optimum.
Although the neural networks used in practice are far from that wide, this still motivates us to design the GGN algorithm.
Neural network structure.
We use the following two-layer network
[Equation]
where x ∈ R
d is the input, M is the network width,
W = ( w (cid:62) 1 , · · · , w (cid:62) M ) (cid:62) and σ ( · ) is the activation function.
Each entry of W is i.i.d.
initialized with the standard Gaussian distribution w r ∼ N (0 , I d ) and each entry of a is initialized from the uniform distribution on {± 1 } .
Similar to Du et al.
(2018b), we only train the network on parameter W just for the clarity of the proof.
We also assume the activation function σ ( · ) is (cid:96) -Lipschitz and β -smooth, and (cid:96) and β are regarded as O (1) absolute constants.
The key ﬁnding, as pointed out in Jacot et al.
Du et al.
(2018b;a), is that under such initialization, the Gram matrix G has an asymptotic limit, which is, under mild conditions (e.g. input data not being degenerate etc., see Lemma F.2 of Du et al.
(2018a)), a positive deﬁnite matrix
[Equation]
Assumption 1 (Least Eigenvalue of the Limit of Gram Matrix) .
We assume the matrix K deﬁned in (13) above is positive deﬁnite, and denote its least eigenvalue as
[Equation]
Now we are ready to state our theorem of full-batch GGN:
Theorem 1 (Quadratic Convergence of Full-batch GGN on Overparameterized Neural Networks) .
Assume Assumption 1 holds.
Assume the scale of the data is (cid:107)
x i (cid:107)
= O (1) , | y i
| =
O (1) for i ∈ { 1 , · · · , n } .
If the network width
[Equation]
then with probability 1 − δ over the random initialization, the full-batch version of GGN whose update rule is given in Eq.
(9) satisﬁes the following:
The Gram matrix G t,S at each iteration is invertible; 2)
The loss converges to zero in a way that
[Equation]
for some C that is independent of M , which is a second-order convergence.
For the mini-batch version of GGN, by the analysis of its NTK limit, the algorithm is essentially doing serial subspace correction (Xu, 2001) on subspaces induced by mini-batch.
So mini-batch
GGN is similar to the Gauss-Siedel method (Golub & Van Loan, 1996) applied to solving systems of linear equations, as shown in the proof of the following theorem.
Similar to the full batch situation,
GGN takes the exact solution of the “kernel regression problem on the subspace” which is faster than just doing a gradient step to optimize on the subspace.
Moreover, we note that existing results of the convergence of SGD on overparameterized networks usually use the idea that when the step size is bounded by a quantity related to smoothness, the SGD can be reduced to GD.
However, our analysis takes a different way from the analysis of GD, thus does not rely on small step size.
In the following, we denote G 0 ∈ R n × n as the initial Gram matrix.
Let n = bk , where b is the batch size and k is the number of batches, and let
[Equation]
be the ( i, j ) -th
b × b block of G 0 .
We deﬁne the iteration matrix
[Equation]
) where
D =  
G [Equation] G
[Equation] G [Equation]
kk   [Equation]
   · · · G
[Equation]
G
[Equation]
k G [Equation] k...
  , represents the block-diagonal and block-lower-triangular parts of G 0 .
We will show that the convergence of mini-batch GGN is highly related to the spectral radius of A .
To simplify the proof, we make the following mild assumption on A :
Assumption 2 (Assumption on the Iteration Matrix) .
Assume the matrix A deﬁned in (15) above is diagonalizable.
So we choose an arbitary diagonalization of A as A = P − 1 QP and denote
[Equation]
We note that Assumption 2 is only for the sake of simplicity.
Even if it does not hold, an inﬁnitesimally small perturbation can make any matrix diagonalizable, and it will not affect the proof.
Now we are ready to state the theorem for mini-batch GGN.
Theorem 2 (Convergence of Mini-batch GGN on Overparameterized Neural Networks) .
Assume
Assumption 1 and 2 hold.
Assume the scale of the data is (cid:107)
x
i (cid:107) 2 =
O (1) ,
| y i |
=
O (1) for i ∈ { 1 , · · · , n } .
We use the mini-batch version of GGN whose update rule is given in Eq.(10), and the batch B t is chosen sequentially and cyclically with a ﬁxed batch size b and k = n/b updates per epoch.
If the network width
[Equation]
then with probability 1 − δ over the random initialization, we have the following:
The Gram matrix G t,B t at each iteration is invertible; 2)
The loss converges to zero in a way that after T epochs, we have
[Equation]
Proof sketch for Theorem 1 and 2.
Denote J t =
J ( W t ) and
[Equation]
For the full-batch version
[Equation]
we have
[Equation]
Then we control the ﬁrst term in Eq.
(17) in a way similar to the following:
[Equation]
and if[-(cid:13) (cid:13) J (cid:62) t (cid:13) (cid:13) 
-]
[Equation]
G − 1 t (cid:13)(cid:13) 2 can be upper bounded, we get our result Eq.
For the mini-batch version, similarly we have
[Equation]
where the subscript B t denotes the sub-matrix/vector corresponding to the batch, and ˜ G − 1 t,B t ∈ R b × n is a zero-padded version of G − 1 t,B t to make Eq.
(18) hold.
Therefore, after one epoch (from the ( tk + 1) -th to the (( t + 1) k ) -th update), we have
[Equation]
We will see that the matrix
A t is close to the matrix A deﬁned in (15), so it boils down to analyzing the spectral properties of A .
For both theorems, we can compute that as M increases, the norm of the update (cid:107) W t − W t +1 (cid:107) F does not increase with M , so the update is small compared to the Gaussian initialization where (cid:107) W 0 (cid:107) 2 = Θ( √ M ) .
From this we can derive that the matrices J , G etc.
remain close to their initialization, which makes bounding their norms possible.
The full proof is in the appendix.
In conclusion, the accelerated convergence is related to the local linearity and the stability of the
Jacobian and Gram matrix.
We emphasize that our theorems serve more as a motivation than a justiﬁcation of our GGN algorithm, because we expect that GGN works in practice, even under milder situations when M is not as large as the theorem demands or for deep networks with different architectures, and that GGN would still perform much better than ﬁrst-order methods.
3. A NALYSIS OF THE P ER - ITERATION C OMPUTATIONAL C OMPLEXITY
We have proved that for sufﬁciently overparametrized deep neural networks, GGN has quadratic convergence rate.
In this subsection, we analyze the per-iteration computational cost of GGN, and compare it to that of SGD.
For every mini-batch (i.e., iteration), there are two major steps of computation in GGN:
• (A).
Forward, and then backpropagate for computing the Jacobian matrix J . • (B).
Use J to compute the update J (cid:62) ( λ G + α I ) − 1 ( f − y )
We show that the computational complexity of (A) is the same as that of SGD with the same batch size; and the computational complexity of (B) is small compared to (A) for typical networks and batch sizes.
Thus, the per-iteration computation overhead of GGN is very small compared to SGD.
Overall, in terms of training time, GGN can be much faster than SGD.
For the computation in step (A), the forward part is just the same as that of SGD.
For the backward part, for every input data , GGN keeps track of the output’s derivative for the nodes in the middle of the computational graph.
This part is just the same as backpropagation in SGD.
What is different is that GGN also, for every input data , keeps track of the output’s derivative for the parameters ; while in
SGD the derivatives for the parameters are averaged over a batch of data .
However, it is not difﬁcult to see the computational costs of GGN and SGD are the same.
For the computation in step (B), observe that the size of the Jacobian is b × m where b is the batch size and m is the number of parameters.
The Gram matrix G t,B t =
J t,B t J (cid:62) t,B t in our GramGauss-Newton method is of size b × b and it only requires O ( b 2 m + b 3 ) for computing G t,B t and a matrix inverse.
Multiplying the two matrices to f − y requires even less computation.
Overall, the computational cost in step (B) is small compared to that of step (A).
E XPERIMENTS
Given the theoretical ﬁndings above, in this section, we compare our proposed GGN algorithm with several baseline algorithms in real applications.
In particular, we mainly study two regression tasks,
AFAD-LITE
Niu et al., 2016) and RSNA Bone Age (rsn, 2017).
4. E XPERIMENTAL SETTING
AFAD-LITE task is to predict the age of human from the facial information.
The training data of the AFAD-LITE task contains 60k facial images and the corresponding age for each image.
We choose ResNet-32 (He et al., 2016) as the base model architecture.
During training, all input images are resized to 64 ∗ 64 .
We study two variants of the ResNet-32 architecture: ResNet-32 with batch normalization layer (referred to as ResNetBN ), and ResNet-32 with Fixup initialization (Zhang et al., 2019b) (referred to as ResNetFixup ).
In both settings, we use SGD as our baseline algorithm.
In particular, we follow Qian (1999) to use its momentum variant and set the hyper-parameters lr= 0 .and momentum= 0 .
9 determined by selecting the best optimization performance using grid search.
Since batch normalization is computed over all samples within a mini-batch, it is not consistent with [Figure] our assumption in Section 2 that the regression function has the form of f ( w , x ) , which only depends on w and a single input datum x .
For this reason, the GGN algorithm does not directly apply to
ResNetBN, and we test our proposed algorithm on ResNetFixup only.
We set λ
= 1 and α = 0 .
3 for
GGN.
We follow the common practice to set the batch size to 128 for our proposed method and all baseline algorithms.
Mean square loss is used for training.
RSNA Bone Age task is a part of the 2017 Pediatric Bone Age Challenge organized by the
Radiological Society of North America (RSNA).
It contains 12,611 labeled images.
Each image in this dataset is a radiograph of a left hand labeled with the corresponding bone age.
During training, all input images are resized to 64 ∗ 64 .
We also choose ResNetBN and ResNetFixup for this experiment, and use ResNetBN and ResNetFixup trained in the ﬁrst task as warm-start initialization.
We use lr = 0 .
01 and momentum = 0 .
9 for SGD, and use λ = 1 and α = 0 .
1 for GGN.
Batch size is set to 128 in these experiments, and mean square loss is used for training.
4. E XPERIMENTAL RESULTS
Convergence.
The training loss curves of different optimization algorithms for AFAD-LITE and
RSNA Bone Age tasks are shown in Figure 1.
On both tasks, our proposed method converges much faster than the baselines.
We can see from Figure 1a and Figure 1b that, on the AFAD-LITE task, the loss using our GGN method quickly decreases to nearly zero in 30 epochs.
On the contrary, for both baselines using SGD, the loss decays much slower than our method in terms of wall clock time and epochs.
Similar advantage of GGN can also be observed on the RSNA bone age task.
Generalization performance and different hyper-parameters.
We can see that our proposed method trains much faster than other baselines. However, as a machine learning model, generalization performance also needs to be evaluated. Due to space limitation, we only provide the test curve for the RSNA Bone Age task in Figure 2a. From the ﬁgure, we can see that the test loss of our proposed method also decreases faster than the baseline methods.
Furthermore, the loss of our GGN algorithm is lower than those of the baselines.
These results show that the GGN algorithm can not only accelerate the whole training process, but also learn better models. Time 0. [Figure] [Figure]
e s t L
[Figure]
ss
[Figure]
[Figure]
10 Epochs 0.
T r a i n i ng L o ss λ =1, α =0.01 λ
=1, α =0.1 λ
=1,
α
= λ =0.25, α =1.0 λ =4, α =0.
(b) 2 −4 2 −2 22 2 λ 2 − 2 − 2 − 22α 10 − 10 − 10 − 10(c)
We then study the effect of hyper-parameters used in the GGN algorithm.
We try different λ
and α on the RSNA Bone Age task and report the training loss of all experiments at the 10 th epoch.
All results are plotted in Figure 2c.
In the ﬁgure, the x-axis is the value of λ and the y-axis is the value of α .
The gray value of each point corresponds to the loss, the lighter the color, the higher the loss.
We can see that the model converges faster when λ is close to 1 .
In GGN, α can be considered as the inverse value of the learning rate in SGD.
Empirically, we ﬁnd that the convergence speed of training loss is not that sensitive to α given a proper λ , such as λ = 1 .
Some training loss curves of different hyper-parameter conﬁgurations are shown in Figure 2b.
C ONCLUSION AND D ISCUSSIONS
We propose a novel Gram-Gauss-Newton (GGN) method for solving regression problems with square loss using overparameterized neural networks.
Despite being a second-order method, the computation overhead of the GGN algorithm at each iteration is small compared to SGD.
We also prove that if the neural network is sufﬁciently wide, GGN algorithm enjoys a quadratic convergence rate.
Experimental results on two regression tasks demonstrate that GGN compares favorably to
SGD on these data sets with standard network architectures.
Our work illustrates that second-order methods have the potential to compete with ﬁrst-order methods for learning deep neural networks with huge number of parameters.
In this paper, we mainly focus on the regression task, but our method can be easily generalized to other tasks such as classiﬁcation as well.
Consider the k -category classiﬁcation problem, the neural network outputs a vector with k entries.
Although this will increase the computational complexity of getting the Jacobian whose size increases k times, i.e., J ∈ R ( bk ) × m , each row of J can be still computed in parallel, which means the extra cost only comes from parallel computation overhead when we calculate in a fully parallel setting.
While most ﬁrst-order methods for training neural networks can hardly make use of the computational resource in parallel or distributed settings to accelerate training, our GGN method can exploit this ability.
For ﬁrst-order methods, basically extra computational resource can only be used to calculate more gradients at a time by increasing batch size, which harms generalization a lot.
But for GGN, more resource can be used to reﬁne the gradients and achieve accelerated convergence speed with the help of second-order information.
It is an important future work to study the application of GGN to classiﬁcation problems.
A S OME P REPARATIONS FOR THE P ROOF OF T HEOREMS
Notations.
We use the following notations for the rest of the sections.
• Let [ n ] = { 1 , · · · , n } .
• J W , x ∈ R M × d denotes the gradient ∂f ( W , x ) ∂ W , which is of the same size of W .
• The bold J W or J ( W ) denotes the Jacobian with regard to all n data, with each gradient for W vectorized,
i
e.
[Equation]
• w r denotes the r -th row of W , which is the incoming weights of the r -th neuron.
• W 0 stands for the parameters at initialization.
• d W , x := σ (cid:48)
( Wx ) ∈ R M × 1 denotes the (entry-wise) derivative of the activation function.
• We use (cid:104)· , ·(cid:105) to denote the inner product, (cid:107)·(cid:107) 2 to denote the Euclidean norm for vectors or the spectral norm for matrices, and (cid:107)·(cid:107) F to denote the Frobenius norm for matrices.
We can easily derive the formula for J as
[Equation]
where ◦ is the point-wise product.
So we can also easily solve G as
[Equation]
Our analysis is based on the fact that G stays not too far from its inﬁnite-width limit
[Equation]
which is a positive deﬁnite matrix with least eigenvalue denoted λ 0 , and we assume λ 0 > 0 .
λ 0 is a small data-dependent constant, and without loss of generality we assume λ 0 ≤ 1 , or else we can just take λ
=
if λ min ( K ) > 1 .
The ﬁrst lemma is about the estimation of relevant norms at initialization.
Lemma 2 (Bounds on Norms at Initialization) .
If M = Ω ( d log(16 n/δ )) , then with probability at least 1 − δ/ 2 the following holds
(a).
(cid:107) W 0 (cid:107)
=
O ( √ M ) .
(b).
f ( W 0 , x i ) =
O (1) , for i ∈ [ n ] .
(c).
(cid:107) J W 0 , x i (cid:107) F = O (1) , for i ∈ [ n ] .
Proof.
(a).
The lemma is a well-known result concerning the estimation of singular values of
Gaussian random matrices (see Corollary 5.35 of Vershynin (2010)).
Notice that W 0 ∈ R M × d is a
Gaussian random matrix, the Corollary states that with probability 1 − 2 e − t 2 / 2 one has
[Equation]
By choosing M = max( d, (cid:112) 2 log(8 /δ )) , we obtain (cid:107) W 0 (cid:107) 2 ≤ 3 √ M with probability 1 − δ/ 4 .
(b).
First, a r , r ∈
[ M ] are Rademacher variables, thereby 1 -sub-Gaussian, so with probability 1 − 2 e − Mt 2 / 2 we have 1 M (cid:80)
Mr =1 a r ≤ t .
This means if we take M = Ω (log [Equation] 16 /δ [Equation]
[Equation]
Next, the vector v i = 1 (cid:107) x i (cid:107) 2 W 0 x i ∈ R M × 1 is a standard Gaussian vector.
Suppose the activation σ ( · ) is l -Lipschitz and l is O (1) by our assumption, with the vector a ﬁxed, the function
[Equation]
has a Lipschitz parameter of l (cid:107) x
i (cid:107) 2 / √ M =
O
(1 / √ M ) .
According to the classic result on the concentration of a Lipschitz function over Gaussian variables (see Theorem 2.26 of Wainwright (2019)), we have
[Equation]
which means if M = Ω(log(16 n/δ )) ,
[Equation]
holds jointly for all i ∈ [ n ] with probability 1 − δ/ 8 .
Note that
[Equation]
Plugging in (22) and (24) into (23), we see that as long as M = Ω(log(16 n/δ )) , then with probability 1 − δ/ 4 , for all i ∈ [ n ] ,
[Equation]
(c).
Since σ is O (1) -Lipschitz, we have (cid:107) d W , x i (cid:107) ∞
=
O (1) .
According to (20) we can easily know that (cid:107) {+J W , x i (cid:107) F ≤ 1 √ M (cid:107) Diag( d ) (cid:107) 2 (cid:107) a (cid:107) 2 (cid:107) x (cid:107) 
+}
= O (1) .
The next lemma is about the least eigenvalue of the Gram matrix G at initialization.
It shows that when M is large, G W 0 is close to K and has a lower bounded least eigenvalue.
It is the same as
Lemma 3.1 in Du et al.
(2018b),
but here we restate it and its proof for the reader’s convenience.
Lemma 3 (Bound on the Least Eigenvalue of the Gram Matrix at Initialization) .
If the width
M = Ω (cid:16) n 2 log(2 n/δ ) λ(cid:17) , then with probability at least 1 − δ/ 2 over random initialization, we have
[Equation]
Proof.
Because σ is Lipschitz, σ (cid:48) ( wx i ) σ (cid:48) ( wx j ) is bounded by O (1) .
For every ﬁxed ( i, j ) pair, at initialization G ij is an average of independent random variables, and by Hoeffding’s inequality, applying union bound for all n 2 of ( i, j ) pairs, with probability 1 − δ/ 2 at initialization we have
[Equation]
(cid:32)(cid:114) log
[Equation]
[Equation]
and then
[Equation]
Thus if M = Ω (cid:16) n 2 log(2 n/δ
[Equation]
λ(cid:17) we can have (cid:107) G W 0 − K (cid:107) 2 ≤ 14 λ 0 and thus λ min ( G W 0 ) ≥ 34 λ 0 .
Next, in Lemma 4 and 5 we will bound the relevant norms and the least eigenvalue of G inside some scope of W that covers the whole optimization trajectory starting from W 0 .
Speciﬁcally, we consider the range
[Equation]
where R is determined later to make sure that the optimization trajectory remains inside B ( R ) .
The idea of the whole convergence theorem is that when the width M is large, R is very small compared to its initialization scale: (cid:107) W 0 (cid:107)
= O ( √ M ) .
This way, neither the Jacobian nor the Gram matrix changes much during optimization.
Lemma 4 (Bounds on Norms in the Optimization Scope) .
Suppose the events in Lemma 2 hold.
There exists a constant C > 0 such that if M ≥ CR 2 , we have the following:
(a) For any W ∈ B ( R ) , we have
[Equation]
(b) For any W 1 , W 2 ∈ B ( R ) , if (cid:107) W 1 − W 2 (cid:107) F ≤ R (cid:48) , then we have (cid:107)
[Equation]
W
[Equation]
, x i
[Equation]
J W 2 , x i (cid:107) F =
[Equation]
(cid:18) R (cid:48) √
[Equation]
(cid:19) , ∀ i, and (cid:107) J W
[Equation]
Also, for any W ∈ B ( R ) , we have
[Equation]
[Equation]
Proof.
(a).
This is straightforward from Lemma 2(a), the deﬁnition of B ( R ) , and M = Ω( R 2 ) .
(b).
According to the O (1) -smoothness of the activation, we have
[Equation]
so we can bound
[Equation]
And according to (19), we have
[Equation]
Also, taking W 1 = W and W 2 = W 0 , combining with Lemma 2(c), we see there exists C such that for M ≥ CR 2 we have (cid:107) J W (cid:107) F
= O (1) , and naturally (cid:107) J W (cid:107)
=
O ( √ n ) .
Note: The constants hidden in the O ( · ) notation are irrelevant with C .
The next Lemma deals with the Gram matrix within B ( R ) , ensuring a lower bound on the least eigenvalue throughout the optimization process (Du et al., 2018a).
Lemma 5 (Least Eigenvalue in the Optimization Scope) .
For W ∈ B ( R ) , suppose the events in
Lemma 2 and 3 hold, there exists a constant C (cid:48) such that for M ≥ C (cid:48) n 2 R 2 λ, we have
[Equation]
and thus combined with Lemma 3, we know that G W remains invertible when W ∈ B ( R ) and satisﬁes (cid:13)(cid:13)
G
[Equation] [Equation]
(cid:13)(cid:13)
[Equation]
Proof.
Based on the results in Lemma 4(b), we have
[Equation] [Equation]
To make the above less than λ 0 4 , choosing M greater than some C (cid:48) n 2 R 2 λsufﬁces, and the lemma is thus proved.
Again the constants hidden in the O ( · ) notation are irrelevant with C (cid:48) .
B P ROOF OF T HEOREM
Proof idea.
In this section, we use W t , t ∈ { 0 , 1 , · · · } to represent the parameter W after t iterations.
For convenience, J t , G t , f t is short for J W t , G W t , f W t respectively.
We introduce
J t,t
[Equation]
=
[Equation] [Equation]
For each iteration, if G t is invertible, we have
[Equation]
hence
[Equation]
Then we control the ﬁrst term of the right hand side based on Lemma 4 in the following form
[Equation]
and plugging into (32) along with norm bounds on J and G we obtain a second-order convergence.
Formal proof.
Let R t = (cid:107) W t − W t +1 (cid:107) F for t ∈ { 0 , 1 , · · · } .
We take R = Θ (cid:16) nλ 0 (cid:17) in Lemmaand 5 (the constant is chosen to make the right hand side of (34) hold).
We prove that there exists an
M = Ω (cid:16) max
[Equation]
n
[Equation]
λ 40 , n 2 d log
[Equation]
16 n/δ ) λ
[Equation]
(cid:17)(cid:17) (with enough constant) that sufﬁces.
First we can easily verify that all the requirements for M in Lemma 2-5 can be satisﬁed .
Hence, with probability at least 1 − δ all the events in Lemma 2-5 hold.
Under this situation, we do induction on t to show the following:
• (a).
W t ∈ B ( R ) .
• (b).
If t > 0 , then (cid:107) f t − y (cid:107) 2 ≤ n 3 / 2 λ 20 √ M (cid:107) f t − 1 − y (cid:107)
As long as (b) is true for all t , then choosing M large enough to make sure the series {(cid:107)
f t − y (cid:107) 2 } ∞ t = converges to zero, we obtain the second-order convergence property.
For t = 0 , (a) and (b) hold by deﬁnition.
Suppose the proposition holds for t = 0 , · · · , T .
Then for t = 0 , · · · , T , G t is invertible.
Recall that the update rule is vec( W t +1 )
= vec( W t ) − J (cid:62) t G − 1 t ( f t − y ) , we have
[Equation]
(Lemma 4 and 5 ) (33)
According to Lemma 2(b) and the assumption that the target label y i
= O (1) , we have (cid:107) f 0 − y (cid:107) 22 =
O ( n ) .
When T > 1 , the decay ratio at the ﬁrst step is bounded as
[Equation]
=: r, and taking M = Ω( n 4 λ 40 ) with enough constant can make sure r is a constant less than 1 , in which case the second-order convergence property (b) will ensure a faster ratio of decay at each subsequent step in (cid:107) f t − y (cid:107)
Tt =0 .
Combining (33), we have
[Equation]
Therefore, W T +1 ∈ B ( R ) , and (34) also holds when T = 0 , so (a) is true.
Since B ( R ) is convex, this means we also have s W T
+ (1 − s ) W T +1 ∈ B ( R ) for s ∈ [0 , 1] .
Hence we can bound the difference of the Jacobian as
[Equation] [Equation]
So we use the bound of (32) and obtain
[Equation] [Equation]
(35) and Lemma
[Equation]
5) which proves (b).
This concludes our proof.
C P ROOF OF T HEOREM
In this section, we give the proof of the convergence of our mini-batch GGN algorithm (Theorem 2).
Some additional notations.
For the convenience of our proof, we will use slightly different notations than that in Section 3.2.
Let n = bk , where b is the batch size, k is the number of batches, or equivalently, number of updates in each epoch.
For epoch t ∈ { 1 , 2 , · · · } and batch i ∈
[ k ] , we will use W ti ∈ R d × M to denote the parameters before the i -th update in epoch t .
Let J ti =
J ( W ti ) ∈ R n × Md , G ti =
G ( W ti ) ∈ R n × n , and f ti =
f ( W ti ) ∈ R n × 1 .
(All of
W 0 , W 1 , W 11 , G 0 , etc. can represent initial values in the proof.)
Also, let W t =
W t 1 , J t =
G t 1 , G t =
J t 1 , f t = f t 1 , and let W t ( k +1)
=
W ( t +1)1 , J t ( k +1) =
J ( t +1)1 , etc.
In the i -th batch, we use the data ( x l , y l ) ibl =(
i − 1) b +1 .
To specify the matrix related to a batch, we use the following indexing method:
For i (cid:48) , i (cid:48)(cid:48) ∈
[ k ] , let
[Equation] [Equation]
Md
[Equation]
∈
[Equation]
, which is the b rows of J ti that represent the Jacobian of the i -th batch.
Similarly, we have
[Equation]
ti,
i
[Equation]
Similar to (31) in the proof of Theorem 1, we make use of the notation
[Equation]
and similarly deﬁne J t ( i,i +1) ,i (cid:48)
∈ R b × Md , etc.
In addition, we make use of the matrix
[Equation]
in the formula of the update.
Similar to the proof of Theorem 1, the idea of our proof is that due to the fact that the change of W is small compared to the scale of its initialization, the matrix J and G remains stable.
Informally, this makes the algorithm close to solving kernel regression iteratively by batches, which is equivalent to solving a system of linear equations
[Equation]
for variables r ∈ R n × 1 (where vec( W ) = vec( W 0 )
+ J (cid:62) r ), using the Gauss-Siedel method, which means solving
[Equation]
for the i -th batch in every epoch.
Therefore, it is natural that the matrix A
=
L (cid:62) ( D − L ) − 1 in (15) is introduced.
We will show later that the real update follows
[Equation]
for some A t ≈ A .
In order to prove the theorem, we need some additional lemmas as follows.
Lemma 6 (Formula for the Update) .
If the Gram matrix at each step is invertible, then:
(a) The update of W is
[Equation]
(b) The formula for f − y is
[Equation]
(c) The update of f − y satisﬁes
[Equation]
where
[Equation]
· · · G tk,kk   , L t = −    · · ·
J t (1 , 2) , 2 J (cid:62) t 1 , · · ·...
J t (1 , 2) ,k J (cid:62) t 1 ,
J t (2 , 3) ,k J (cid:62) t 2 ,· · ·  , and
U ti =
Diag   −  
J t (1 , 2) , 1 J (cid:62) t 1 , 1 − G t 1 ,
J t (2 , 3) , 1 J (cid:62) t 2 ,· · ·
J t ( i,i +1) , 1 J (cid:62) ti,
i
J t (2 , 3) , 2 J (cid:62) t 2 , 2 − G t 2 ,· · ·
J t ( i,i +1) , 2 J (cid:62) ti,i .
· · · J t ( i,i +1) ,i J (cid:62) ti,i − G ti,ii   ib × ib ,  
G t ( i +1) , ( i +1)( i +1) · · ·
J t ( i +1 ,i +2) ,i +2 J (cid:62) t ( i +1) ,i +
G t ( i +2) , ( i +2)
( i +2) · · · ...
J t ( i +1 ,i +2) ,k J (cid:62) t ( i +1) ,i +
J t ( i +2 ,i +3) ,k J (cid:62) t ( i +2) ,i + · · · G tk,kk   ( k − i )
b × ( k − i ) b   .
Or, if we denote
U
[Equation]
k −
[Equation] [Equation]
( k −
[Equation] [Equation]
(cid:21) , then we have
[Equation] [Equation]
Speciﬁcally, we have
[Equation]
43) where
[Equation]
Proof.
(a) For (38), this is exactly the update formula (10) for the i -th batch where the Jacobian and
Gram matrix are J ti,i and G ti,ii respectively.
Note that
[Equation]
we then obtain (39) from (38).
(b).
We have
[Equation]
formula (39)) , we obtain (40).
(c).
Based on (40) we know that
[Equation]
where the index goes in decreasing order from left to right.
So in order to prove (41) we only need to prove that
[Equation]
which we will prove by induction on i .
For i =
it is trivial that D t − L t =
U t 0 by deﬁnition.
Suppose (44) holds for i
[Equation]
then
[Equation]
+1) ,i +1 .
J t ( i +1 ,i +2) ,k J (cid:62) t ( i +1) ,i +   (cid:2)
b × ( ib )
I b × b 0 b × ( k − i − 2) b (cid:3)
=
U t ( i +1) , which proves (41).
Note that by the deﬁnition, we have U ti =
D ti − L ti , we can then obtain (42) by
U ti ( D t − L t ) − 1 = (cid:20) ˜
U ti
[Equation]
=
[Equation] [Equation]
I
[Equation]
By (43), we can see that the iteration matrix A t is close to the matrix A deﬁned in (15).
The convergence of the algorithm is much related to the eigenvalues of A .
In the next two lemmas, we bound the spectral radius of A and provide an auxiliary result on the convergence on perturbed matrices based on the spectral radius.
Lemma 7.
Suppose the least eigenvalue of the initial Gram matrix G 0 satisﬁes λ
[Equation]
, (which is true with probability 1 − δ if M = Ω (cid:16)
[Equation] [Equation]
(cid:17) , according to Lemma 3).
Also assume (cid:107) J W 0 , x l (cid:107) F
= O (1) for any l ∈ [ n ] (which is true with probability 1 − δ , according to Lemma 2).
Then the spectral radius A , or equivalently, maximum norm of eigenvalues of A , denoted ρ ( A ) , satisﬁes
[Equation]
Proof.
For any eigenvalue λ ∈ C of A , it is an eigenvalue of A (cid:62) , so there exists a corresponding unit vector v ∈ C n × 1 such that λ v =
A (cid:62) v =
( D − L (cid:62) )
− 1 Lv , which means
[Equation]
Since G 0 = D − L − L (cid:62) is positive deﬁnite with eigenvalues at least 34 λ 0 , we have v ∗ ( D − L −
L (cid:62) ) v ≥ 34 λ 0 , which means
[Equation]
(47) where d = v ∗ Dv , l = v ∗ Lv , and v ∗ L (cid:62) v = l .
Let v i = v (( i − 1) b +
: ib ) ∈ R b × 1 be the i -th batch of the vector v , and ˜ v i =
[ 0 1 × ( i − 1) b , v (cid:62) i , 0 1 × ( k − i )
b ] (cid:62) ∈ R n × 1 .
It is not hard to see that
[Equation]
Also, since by our assumption each entry of L (or of G 0 ) is at most O (1) , we have
[Equation]
Now we use take an inner product of v with (46) and get
[Equation]
50) and therefore | λ | =
[Equation]
(By solving (50)) = (cid:115) | l |
[Equation] [Equation]
( d
[Equation]
(cid:115) d ( d − 2Re( l
[Equation]
| l |+≤ (cid:118)(cid:117)(cid:117)(cid:116) Ω (cid:16) λ 20 n 2 (cid:17)
+(Using (47), (48), (49))
= 1 − Ω (cid:18) λn(cid:19) .
This concludes the proof for this lemma.
Lemma 8.
Denote ρ ( A )
=
ρ 0 ≤ 1 .
Let A be diagonalized as A
= P − 1 QP and µ = (cid:107) P (cid:107)
(cid:13)(cid:13)
P − 1 (cid:13)(cid:13)(see Assumption 2 ).
Suppose we have (cid:107) A t − A 0 (cid:107) 2 ≤ δ for t ≤ T , then (cid:13)(cid:13)(cid:13)(cid:13) (cid:13)
T (cid:89) i =
A t (cid:13)(cid:13)(cid:13)(cid:13) (cid:13)≤ µ ( ρ + µδ ) T
Proof.
We have
[Equation]
In addition to the bounds used in Theorem
[Equation]
we provide the next lemma with useful bounds of the norms and eigenvalues
[Equation]
Lemma 9 (Relevant Bounds for the Matrices in the Optimization Scope) .
We assume the events in
Lemma 2 and 3 hold, and let M =
Cµ 2 n 8 R 2 λfor some large enough constant C , then:
For any ( t, i ) -pair, we assume W t (cid:48) i (cid:48) ∈ B ( R ) for all i (cid:48) ∈
[ k ] when t (cid:48) ≤ t and i (cid:48)
∈
[ i ] when t (cid:48)
=
t in the following propositions.
[Equation]
a).
[Equation]
D − L )
[Equation]
(b).
Suppose up to t , W t is in B ( R ) (which means for i (cid:48) ∈
[ k + 1] , and t (cid:48) ∈
[ t − 1] , W ti ∈ B ( R ) ).
Then (cid:107)
A t − A (cid:107)
≤
− ρ ( A µ .
Proof.
(a).
Because for (cid:107) v (cid:107) 2 = 1 , (cid:107)
[Equation]
D
[Equation]
≥
[Equation] [Equation]
(By the positive-deﬁniteness of G 0 and Lemma 3) (b).
By Lemma 4 we know that within B ( R ) , the size of the Jacobian (cid:107) J x l (cid:107) F w.r.t.
data x l is O (1) , and the difference (cid:107) J W 1 , x l − J W 2 , x l (cid:107) F within O ( R ) is bounded by O (cid:16) R √ M (cid:17) , this can be applied to each entry of D , L , U , etc., including those J t (cid:48)
( i (cid:48) ,i (cid:48) +1) terms by the convexity of B ( R ) , and we can see that each entry of these matrices has size at most O (1) and varies inside an O (cid:16) R √ M (cid:17) range.
Therefore we get
[Equation]
and
[Equation]
By our chosen M , O (cid:16) Rn √ M (cid:17) ≤ 18 λ 0 can deﬁnitely hold, so along with (a) we have
[Equation]
Hence,
[Equation]
= O
[Equation]
, and along with Lemma 7, in order to have (cid:107)
A t − A (cid:107) 2 ≤ 1 − ρ ( A ) 2 µ , all we need is
[Equation]
R
[Equation]
M
[Equation]
so choosing some M =
Cµ 2 n 8 R 2 λsufﬁces.
With all the preparations, now we are ready to prove Theorem 2.
The logic of the proof is just the same as what we did in the formal proof of Theorem 1, where we then used induction on t and now we use induction on the pair ( t, i ) .
The key, is still selecting some R so that in each step W ti remains in B ( R ) .
Combined with the previous Lemmas, in B ( R ) we have A t being close to A , and then convergence is guaranteed.
Formal proof of Theorem 2.
Let R ti =
(cid:13)(cid:13) W t ( i +1) − W ti
(cid:13)(cid:13) F .
We take
[Equation]
in the range B ( R ) (where the constant is chosen to make the right hand side of (52) hold).
We prove that there exists an
[Equation]
with a large enough constant that sufﬁces.
First we can easily verify that all the requirements for M in Lemma 2-9 (most importantly, Lemma 9) can be satisﬁed.
Hence, with probability at least 1 − δ all the events in Lemma 2-9 hold.
Under this situation, we do induction on ( t, i ) ( t ∈ { 1 , 2 , · · · } , i ∈ [ k ] , by dictionary order) to show that:
• W ti ∈ B ( R ) .
For ( t, i ) =
(1 , 1) , it holds by deﬁnition.
Suppose the proposition holds up to ( t, i ) .
Then since W ti ∈ B ( R ) , by Lemma 4 we know that λ min ( G ti ) ≥ λ 0 2 .
This naturally gives us λ min ( G ti,ii ) ≥ λ 0 2 , which means G ti,ii is invertible.
Similar to the argument in the proof of Lemma 9, we know that each entry of
J ti , J t ( i,i +1) , D ti , L ti , U ti , etc., whose index of ( t (cid:48) , i (cid:48) ) only contains i (cid:48) with i (cid:48) ≤ i , is of scale
O (1) and varies at most O (cid:16) R √ M (cid:17) , which is a result of Lemma 4.
Then we know
[Equation]
etc.
We then also know
[Equation]
Since we can also have (cid:13)(cid:13) (( D t − L t ) − ( D − L )) (1:( i − 1) b, 1:( i − 1) b ) (cid:13)(cid:13)
F ≤ O (cid:16) nR √ M (cid:17) , and given our choice of M and R the right hand side is less than 18 λ 0 , along with Lemma (9) (which says
[Equation]
[Table]
[Equation]
and naturally, since this matrix is block-lower-triangular,
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
holds) we know that ˜ D t − ˜
L t is invertible and has the bound (cid:13) (cid:13) (cid:13) ( ˜ D
[Equation]
−
[Equation]
(cid:13) (cid:13) (cid:13) 2 ≤ 4 λ 0 .
Based on the update rule (38), we have
[Equation]
≤
[Equation]
[Table] [Table]
[Equation]
[Table]
(cid:18)(cid:13)(cid:13)
[Equation]
[Table] [Table]
[Table]
(cid:18)
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation] [Equation]
I
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
(cid:21)(cid:13)(cid:13)(cid:13)(cid:13)
[Table]
(cid:107) f
[Table]
[Equation]
y (cid:107)
[Table]
(By formula (42))
[Table]
[Equation]
i
[Equation]
[Table]
[Equation]
i
[Equation]
[Table]
+ (cid:13)(cid:13)(cid:13)
[Equation]
i
[Equation] [Equation]
t ( i
[Equation] [Equation]
(cid:13)(cid:13)(cid:13) F + (cid:13)(cid:13) I ( k − i +1)
b (cid:13)(cid:13) F (cid:1) (cid:107) f t − y (cid:107)≤ O (cid:18) n
[Equation]
/λ(cid:19)
(cid:107) f t − y (cid:107)(51) ≤ O (cid:18) n
[Equation]
/λ(cid:19)
(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) t − 1 (cid:89) i =
A t (cid:13) (cid:13)(cid:13)(cid:13)(cid:13) (cid:107) f 1 − y (cid:107)(By Eq.
≤ O (cid:18) n 3 /λ(cid:19) · µ (cid:18) 1 − Ω (cid:18) λn(cid:19)(cid:19) ( t − 1) (cid:107) ( f 1 − y )
(cid:107)(Lemma 7, 8, and 9(b).)
≤ O (cid:18) µnλ(cid:19) (cid:18) 1 − Ω (cid:18) λn(cid:19)(cid:19) ( t − 1) , (Lemma 2) where Eq.
(51) uses the following bounds proved above:
[Equation]
[Table]
(cid:18)
[Table] [Table]
Since this also hold for previous ( t, i ) pairs, we have
[Equation]
which is the reason why we need to take R = Θ (cid:16) n 5 λ 40 (cid:17) .
This means that W ti ∈ B ( R ) holds.
And by induction, we have proved that W remains in B ( R ) throughout the optimization process.
The last thing to do is to bound f t − y .
By the same logic from above, we have
[Equation]
which proves our theorem.
D A DDITIONAL E XPERIMENTAL R ESULTS
In this section, we give test performance curve of AFAD-LITE dataset in Figure 3 under the same setting with Section 4.
In addition, we provide more baseline results, e.g. Adam (Kingma & Ba, 2014) and K-FAC (Martens & Grosse, 2015) on RSNA Bone Age dataset.
Since we ﬁnd that, as another alternation of BN,
Group Normalization (GN) (Wu & He, 2018) can largely improve the performance of Adam, we also implement the GN layer for our GGN method.
We use grid search to obtain approximately best hyper-parameters for every experiment.
All experiments are performed with batch size 128, input size 64*64 and weight decay 10 − 4 .
We set the number of groups to 8 for ResNetGN.
Other hyper-parameters are listed below.
• SGD+ResNetBN: learning rate 0.01, momentum 0.9.
• Adam+ResNetBN: learning rate 0.001.
• SGD+ResNetGN: learning rate 0.002, momentum 0.9.
Adam+ResNetGN: learning rate 0.0005.
• K-FAC+ResNet: learning rate 0.02, momentum 0.9, (cid:15) = 0 .
1 , update frequency 100.
• GGN+ResNetGN: λ = 1 , α = 0 .
The convergence results are summarized in Figure 4.
Note to make comparison clearer, we use logarithmic scale for training curves.
[Figure]
[Figure]