{'fraction_non_alphanumeric': 0.03230497880372559, 'fraction_numerical': 0.011820404121669709, 'mean_word_length': 4.520669627605057, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Hessian-based Analysis of Large Batch Training and Robustness to Adversaries

Large batch size training of Neural Networks has been shown to incur accuracy loss when trained with the current methods. The exact underlying reasons for this are still not completely understood. Here, we study large batch size training through the lens of the Hessian operator and robust optimization. In particular, we perform a Hessian based study to analyze exactly how the landscape of the loss function changes when training with large batch size. We compute the true Hessian spectrum, without approximation, by back-propagating the second derivative. Extensive experiments on multiple networks show that saddle-points are not the cause for generalization gap of large batch size training, and the results consistently show that large batch converges to points with noticeably higher Hessian spectrum. Furthermore, we show that robust training allows one to favor flat areas, as points with large Hessian spectrum show poor robustness to adversarial perturbation. We further study this relationship, and provide empirical and theoretical proof that the inner loop for robust training is a saddle-free optimization problem \textit{almost everywhere}. We present detailed experiments with five different network architectures, including a residual network, tested on MNIST, CIFAR-10, and CIFAR-100 datasets. We have open sourced our method which can be accessed at [1].


Introduction
During the training of a Neural Network (NN), we are given a set of input data x with the corresponding labels y drawn from an unknown distribution P. In practice, we only observe a set of discrete examples drawn from P, and train the NN to learn this unknown distribution. This is typically a non-convex optimization problem, in which the choice of hyper-parameters would highly affect the convergence properties. In particular, it has been observed that using large batch size for training often results in convergence to points with poor convergence properties. The main motivation for using large batch is the increased opportunities for data parallelism which can be used to reduce training time [14,17]. Recently, there have been several works that have proposed different methods to avoid the performance loss with large batch [17,31,33]. However, these methods do not work for all networks and datasets. This has motivated us to revisit the original problem and study how the optimization with large batch size affects the convergence behavior.
We first start by analyzing how the Hessian spectrum and gradient change during training for small batch and compare it to large batch size and then draw connection with robust training.
In particular, we aim to answer the following questions: Q1 How is the training for large batch size different than small batch size? Equivalently, what is the difference between the local geometry of the neighborhood that the model converges when large batch size is used as compared to small batch? A1 We backpropagate the second-derivative and compute its spectrum during training. The results show that despite the arguments regarding prevalence of saddle-points plaguing optimization [7,13], that is actually not the problem with large batch size training, even when batch size is increased to the gradient descent limit. In [20], an approximate numerical method was used to approximate the maximal eigenvalue at a point. Here, by directly computing the spectrum of the true Hessian, we show that large batch size progressively gets trapped in areas with noticeably larger spectrum (and not just the dominant eigenvalue). For details please see §2, especially Figs. 1, 2 and 4.
Q2 What is the connection between robust optimization and large batch size training? Equivalently, how does the batch size affect the robustness of the model to adversarial perturbation?
A2 We show that robust optimization is antithetical to large batch training, in the sense that it favors areas with small spectrum (aka flat minimas). We show that points converged with large batch size are significantly more prone to adversarial attacks as compared to a model trained with small batch size. Furthermore, we show that robust training progressively favors the opposite, leading to points with flat spectrum and robust to adversarial perturbation. We provide empirical and theoretical proof that the inner loop of the robust optimization, where we find the worst case, is a saddle-free optimization problem almost everywhere. Details are discussed in §3, especially Table 1, 7 and Figs. 4,6. Limitations: We believe it is critical for every paper to clearly state limitations. In this work, we have made an effort to avoid reporting just the best results, and repeated all the experiments at least three times and found all the findings to be consistent. Furthermore, we performed the tests on multiple datasets and multiple models, including a residual network, to avoid getting results that may be specific to a particular test. The main limitation is that we do not propose a solution for large batch training. We do offer analytical insights into the relationship between large batch and robust training, but we do not fully resolve the problem of large batch training. There have been several approaches to increasing batch size proposed so far [17,31,33], but they only work for particular cases and require extensive hyper-parameter tuning. We are performing an in-depth follow up study to use the results of this paper to better guide large batch size training.
Related Work. Deep neural networks have achieved good performance for a wide range of applications. The diversity of the different problems that a DNN can be used for, has been related to their efficiency in function approximation [2,8,22,27]. However the work of [34] showed that not only the network can perform well on a real dataset, but it can also memorize randomly labeled data very well. Moreover, the performance of the network is highly dependent on the hyper-parameters used for training. In particular, recent studies have shown that Neural Networks can easily be fooled by imperceptible perturbations to input data [16]. Moreover, multiple studies have found that large batch size training suffers from poor generalization capability [17,33].
Here we focus on the latter two aspects of training neural networks. [20] presented results showing that large batches converge to a "sharper minima". It was argued that even if the sharp minima has the same training loss as the flat one, small discrepancies between the test data and the training data can easily lead to poor generalization performance [10,20]. The fact that "flat minimas" generalize well goes back to the earlier work of [19]. The authors relate flat minima to the theory of minimum description length [28], and proposed an optimization method to actually favor flat minimas. There have been several similar attempts to change the optimization algorithm to find "better" regions [6,9]. For  Figure 2: The landscape of the loss is shown along the dominant eigenvector, v 1 , of the Hessian for C1 on CIFAR-10 dataset. Here is a scalar that perturbs the model parameters along v 1 .
instance, [6] proposed entropy-SGD, which uses Langevin dynamics to augment the loss functional to favor flat regions of the "energy landscape". The notion of flat/sharpness does not have a precise definition. A detailed comparison of different metrics is discussed in [10], where the authors show that sharp minimas can also generalize well. The authors also argued that the sharpness can be arbitrarily changed by reparametrization of the weights. However, this won't happen when considering the same model and just changing the training hyper-parameters which is the case here. In [30,31], the authors proposed that the training can be viewed as a stochastic differential equation, and argued that the optimum batch size is proportional to the training size and the learning rate.
As our results show, there is an interleaved connection by studying when NNs do not work well. [16,32] found that they can easily fool a NN with very good generalization by slightly perturbing the inputs. The perturbation magnitude is most of the time imperceptible to human eye, but can completely change the networks prediction. They introduced an effective adversarial attack algorithm known as Fast Gradient Sign Method (FGSM). They related the vulnerability of the Neural Network to linear classifiers and showed that RBF models, despite achieving much smaller generalization performance, are considerably more robust to FGSM attacks. The FGSM method was then extended in [21] to an iterative FGSM, which performs multiple gradient ascend steps to compute the adversarial perturbation. Adversarial attack based on iterative FGSM was found to be stronger than the original one step FGSM. Various defenses have been proposed to resist adversarial attacks [3,12,15,18,26]. We will later show that there is an interleaved connection between robustness of the model and the large batch size problem.
The structure of this paper is as follows: We present the results by first analyzing how the spectrum changes during training, and test the generalization performances of the model for different batch sizes in §2. In §3, we discuss details of how adversarial attack/training is performed. In particular, we provide theoretical proof that finding adversarial perturbation is a saddle-free problem under certain conditions, and test the robustness of the model for different batch sizes. Also, we present results showing how robust training affects the spectrum with empirical studies. Finally, in §4 we provide concluding remarks.

Large Batch, Generalization Gap and Hessian Spectrum
Setup: The architecture for the networks used is reported in Table 6. In the text, we refer to each architecture by the abbreviation used in this table. Unless otherwise specified, each of the batch sizes are trained until a training loss of 0.001 or better is achieved. Different batches are trained under the same conditions, and no weight decay or dropout is used.
We first focus on large batch size training versus small batch and report the results for large batch training for C1 network on CIFAR-10 dataset, and M1 network on MNIST are shown in Table 1, and Table 7, respectively. As one can see, after a certain point increasing batch size results in performance degradation on the test dataset. This is in line with results in the literature [17,20].
As discussed before, one popular argument about large batch size's poor generalization accuracy has been that large batches tend to get attracted to "sharp" minimas of the training loss. In [20] an approximate metric was used to measure curvature of the loss function for a given model parameter.
Here, we directly compute the Hessian spectrum, using power iteration by back-propagating the matvec of the Hessian [25]. Unless otherwise noted, we continue the power iterations until a relative error of 1E-4 reached for each eigenvalue. The Hessian spectrum for different batches is shown in Fig. 1. Moreover, the value of the dominant eigenvalue, denoted by λ θ 1 , is reported in Table 1, and Table 2, respectively (Additional result for MNIST tested using LeNet-5 is given in appendix. Please see Table 7). From Fig. 1 This is reflected in the visual figures. We have also added a 3D plot, where we perturb the parameters of C1 model along both the first and second eigenvectors as shown in Fig. 3. The visual results are in line with the numbers shown for the Hessian spectrum (see λ θ 1 ) in Table 1, and Table 7. For instance, note the value of λ θ 1 for the training and test loss for B = 256, 2048 in Table 1 and compare the corresponding results in Fig. 3.
A recent argument has been that saddle-points in high dimension plague optimization for neural networks [7,13]. We have computed the dominant eigenvalue of the Hessian along with the total gradient during training and report it in Fig. 4. As we can see, large batch size progressively gets attracted to areas with larger spectrum, but it clearly does not get stuck in saddle points [23]. Table 1: Result on CIFAR-10 dataset using C1, C2 network. We show the Hessian spectrum of different batch training models, and the corresponding performances on adversarial dataset generated by training/testing dataset (testing result is given in parenthese).

Large Batch, Adversarial Attack and Robust training
We first give a brief overview of adversarial attack and robust training and then present results connecting these with large batch size training.

Robust Optimization and Adversarial Attack
Here we focus on white-box adversarial attack, and in particular the optimization-based approach both for the attack and defense. Suppose M(θ) is a learning model (the neural network architecture), and (x, y) are the input data and the corresponding labels. The loss functional of the network with parameter θ on (x, y) is denoted by J (θ, x, y). For adversarial attack, we seek a perturbation ∆x (with a bounded L ∞ or L 2 norm) such that it maximizes J (θ, x, y): where U is an admissibility set for acceptable perturbation (typically restricting the magnitude of the perturbation). A typical choice for this set is U = B(x, ), a ball of radius centered at x. A popular method for approximately computing ∆x, is Fast Gradient Sign Method [16], where the gradient of the loss functional is computed w.r.t. inputs, and the perturbation is set to: This is not the only attack method possible. Other approaches include an iterative FGSM method (FGSM-10) [21] or using other norms such as L 2 norm instead of L ∞ (We denote the L 2 method by L 2 Grad in our results). Here we also use a second-order attack, where we use the Hessian w.r.t. input to precondition the gradient direction with second order information; please see Table 5 in Appendix for details.
One method to defend against such adversarial attacks, is to perform robust training [24,32]: Solving this min-max optimization problem at each iteration requires first finding the worst adversarial perturbation that maximizes the loss, and then updating the model parameters θ for those cases.
Since adversarial examples have to be generated at every iteration, it would not be feasible to find the exact perturbation that maximizes the objective function. Instead, a popular method is to perform a single or multiple gradient ascents to approximately compute ∆x. After computing ∆x at each iteration, a typical optimization step (variant of SGD) is performed to update θ.
Next we show that solving the maximization part is actually a saddle-free problem almost everywhere. This property assures us that the Hessian w.r.t input does not have negative eigenvalue which allows us to use CG for performing Newton solver for our 2nd order adversarial perturbation tests in §3.4. 2

Adversarial perturbation: A saddle-free problem
Recall that our loss functional is J (θ; x, y). We make following assumptions for the model to help show our theoretical result, Assumption 1. We assume the model's activation functions are strictly ReLu activation, and all layers are either convolution or fully connected. Here, Batch Normalization layers are accepted. Note that even though the ReLu activation has discontinuity at origin, i.e. x = 0, ReLu function is twice differentiable almost everywhere.
The following theorem shows that the problem of finding an adversarial perturbation that maximized J , is a saddle-free optimization problem, with a Positive-Semi-Definite (PSD) Hessian w.r.t. input almost everywhere. For details on the proof please see Appendix. A.1. Theorem 1. With Assumption. 1, for a DNN, its loss functional J (θ, x, y) is a saddle-free function w.r.t. input x almost everywhere, i.e.
From the proof of Theorem 1, we could immediately get the following proposition of DNNs: Proposition 2. Based on Theorem 1 with Assumption 1, if the input x ∈ R d and the number of the output class is c, i.e. y ∈ {1, 2, 3 . . . , c}, then the Hessian of DNNs w.r.t. to x is almost a rank c matrix almost everywhere; see Appendix A.1 for details.   Figure 4: Changes in the dominant eigenvalue of the Hessian w.r.t weights and the total gradient is shown for different epochs during training. Note the increase in λ θ 1 (blue curve) for large batch v.s. small batch. In particular, note that the values for total gradient along with the Hessian spectrum show that large batch does not get "stuck" in saddle points, but areas in the optimization landscape that have high curvature. More results are shown in Fig. 16. The dotted points show the corresponding results when using robust optimization, which makes the solver stay in areas with smaller spectrum.

Large Batch Training and Robustness
Here, we test the robustness of the models trained with different batches to an adversarial attack. We use Fast Gradient Sign Method for all the experiments (we did not see any difference with FGSM-10 attack). The adversarial performance is measured by the fraction of correctly classified adversarial inputs. We report the performance for both the training and test datasets for different values of = 0.02, 0.01 ( is the metric for the adversarial perturbation magnitude in L ∞ norm). The performance results for C1, and C2 models on CIFAR-10, CR model on CIFAR-100, are reported in the last two columns of Tables 1,and 2 (MNIST results are given in appendix, Table 7). The interesting observation is that for all the cases, large batches are considerably more prone to adversarial attacks as compared to small batches. This means that not only the model design affects the robustness of the model, but also the hyper-parameters used during optimization, and in particular the properties of the point that the model has converged to. From this result, there seems to be a strong correlation between the spectrum of the Hessian w.r.t. θ and how robust the model is. However, we want to emphasize that in general there is no correlation between the Hessian w.r.t. weights and the robustness of the model w.r.t. the input. For instance, consider a two variable function J (θ, x) (we treat θ and x as two single variables), for which the Hessian spectrum of θ has no correlation to robustness of J w.r.t.
x. This can be easily demonstrated for a least squares problem, L = θx − y 2 2 . It is not hard to see the Hessian of θ and x are, xx T and θθ T , respectively. Therefore, in general we cannot link the Hessian spectrum w.r.t. weights to robustness of the network. However, the numerical results for all the neural networks show that x for these datasets as well. These two metrics are reported in λ x 1 , and ∇ x J ; see Table 1 for details. The results on all of our experiments show that these two metrics actually do not correlate with the adversarial accuracy. For instance, consider C1 model with B = 512. It has both smaller gradient and smaller Hessian eigenvalue w.r.t.
x as compared to B = 32, but it performs acidly worse under adversarial attack. One possible reason for this could be that the decision boundaries for large batches are less stable, such that with small adversarial perturbation the model gets fooled.

Adversarial Training and Hessian Spectrum
In this part, we study how the Hessian spectrum and the landscape of the loss functional change after adversarial training is performed. Here, we fix the batch size (and all other optimization hyper-parameters) and use five different adversarial training methods as described in §3.1. For the sake of clarity let us denote D to be the test dataset which can be the original clean test dataset or one created by using an adversarial method. For instance, we denote D F GSM to be the adversarial dataset generated by FGSM, and D clean to be the original clean test dataset.
Setup: For the MNIST experiments, we train a standard LeNet on MNIST dataset [4] (using M1 network). For the original training, we set the learning rate to 0.01 and momentum to 0.9, and decay the learning rate by half after every 5 epochs, for a total of 100 epochs. Then we perform an additional five epochs of adversarial training with a learning rate of 0.01. The perturbation magnitude, , is set to 0.1 for L ∞ attack and 2.8 for L 2 attack. We also present results for C3 model [5] on CIFAR-10, using the same hyper-parameters, except that the training is performed for 100 epochs. Afterwards, adversarial training is performed for a subsequent 10 epochs with a learning rate of 0.01 and momentum of 0.9 (the learning rate is decayed by half after five epochs). Furthermore, the adversarial perturbation magnitude is set to = 0.02 for L ∞ attack and 1.2 for L 2 attack [29].
The results are shown in Table 3, 4. We can see that after adversarial training the model becomes more robust to these attacks. Note that the accuracy of different adversarial attacks varies, which is expected since the various strengths of different attack method. In addition, all adversarial training methods improve the robustness on adversarial dataset, though they lose some accuracy on D clean , which is consistent with the observations in [16]. As an example, consider the second row of Table 3 which shows the results when FGSM is used for robust training. The performance of this model when tested against the L 2 GRAD attack method is 63.46% as opposed to 14.32% of the original model (M ORI ). The rest of the rows show the results for different algorithms. In §A.4, we give further discussion about the performances of first order and second order attacks.
The main question here is how the landscape of the loss functional is changed after these robust optimizations are performed? We first show a 1-D parametric interpolation between the original model parameters θ and that of the robustified models, as shown in Fig. 5 (see Fig. 11 for all cases) and 10. Notice the robust models are at a point that has smaller curvature as compared to the original model. To exactly quantify this, we compute the spectrum of the Hessian as shown in Fig. 6, and 12.
Besides the full Hessian spectrum, we also report the spectrum of sub-sampled Hessian. The latter is computed by randomly selecting a subset of the training dataset. We denote the size of this subset as B H to avoid confusion with the training batch size. In particular, we report results for B H = 1 and B H = 320. There are several important observations here. First, notice that the spectrum of the robust models is noticeably smaller than the original model. This means that the min-max problem of Eq. 3 favors areas with lower curvature. Second, note that even though the total Hessian shows that we have converged to a point with positive curvature (at least based on the top 20 eigenvalues), but that is not necessarily the case when we look at individual samples (i.e. B H = 1). For a randomly selected batch of B H = 1, we see that we have actually converged to a point that has both positive and negative curvatures, with a non-zero gradient (meaning it is not a saddle point). To the best of our knowledge this is a new finding, but one that is expected as SGD optimizes the expected loss instead of individual ones. Now going back to Fig. 4, we show how the spectrum changes during training when we use robust optimization. We can clearly see that with robust optimization the solver is pushed to areas with smaller spectrum. This is a very interesting finding and shows the possibility of using robust training as a systematic means to bias the solver to avoid sharp minimas. A preliminary result is shown in Table 8, where we can see that robust optimization performs better for large batch size training as opposed to the baseline, or when we use the method proposed by [17]. However, we emphasize that the goal is to perform analysis to better understand the problems with large batch size training. More extensive tests are needed before one could claim that robust optimization performs better than other methods.

Conclusion
In this work, we studied NNs through the lens of the Hessian operator. In particular, we studied large batch size training and its connection with stability of the model in the presence of white-box adversarial attacks. By computing the Hessian spectrum we provided several points of evidence that show that large batch size training tends to get attracted to areas with higher Hessian spectrum. We reported the eigenvalues of the Hessian w.r.t. whole dataset, and plotted the landscape of the loss when perturbed along the dominant eigenvector. Visual results were in line with the numerical values for the spectrum. Our empirical results show that adversarial attacks/training and large batches are closely related. We provided several empirical results on multiple datasets that show large batch size training is more prone to adversarial attacks (more results are provided in the supplementary material). This means that not only is the model design important, but also that the optimization hyper-parameters can drastically affect a network's robustness. Furthermore, we observed that robust training is antithetical to large batch size training, in the sense that it favors areas with noticeably smaller Hessian spectrum w.r.t. θ.
The results show that the robustness of the model does not (at least directly) correlate with the Hessian w.r.t. x. We also found that this Hessian is actually a PSD matrix, meaning that the problem of finding the adversarial perturbation is actually a saddle-free problem almost everywhere for cases that satisfy this criterion 1. Furthermore, we showed that even though the model may converge to an area with positive curvature when considering all of the training dataset (i.e. total loss), if we look at individual samples then the Hessian can actually have significant negative eigenvalues. From an optimization viewpoint, this is due to the fact that SGD optimizes the expected loss and not the individual per sample loss.

A Appendix
A.1 Proof of Theorem 1 In this section, we give the proof of Theorem 1. The first thing we want to point out is that, although we prove the Hessians of these NNs are positive semi-definite almost everywhere, these NNs are not convex w.r.t. inputs, i.e., x. The discontinuity of ReLU is the cause. (For instance, consider a combination of two step functions in 1-D, e.g. f (x) = 1 x≥1 + 1 x≥2 is not a convex function but has 0 second derivative almost everywhere.) However, this has an important implication, that the problem is saddle-free.
Before we go to the proof of Theorem 1, let us prove the following lemma for cross-entropy loss with soft-max layer.
Further, it is not hard to see that Assume the input of the soft-max layer is s and the cross-entropy is L(s, y). Based on Chain Rule, it follows that ∂J (θ, x, y) ∂x = ∂L ∂s ∂s ∂x .
From Assumption. 1 we know that all the layers before the soft-max are either linear or ReLU, which indicates ∂ 2 s ∂x 2 = 0 (a tensor) almost everywhere. Therefore, applying chain rule again for the above equation, It is easy to see ∂ 2 J (θ, x, y) ∂x 2 0 almost everywhere since ∂ 2 L ∂s 2 0 from Lemma 3.
From above we could see that the Hessian of NNs w.r.t. x is at most a rank c (the number of class) matrix, since the rank of the Hessian matrix is dominated by the term ∂ 2 L ∂s 2 , which is at most rank c.

A.2 Attacks Mentioned in Paper
In this section, we show the details about the attacks used in our paper. Please see Table 5 for details.

A.3 Models Mentioned in Paper
In this section, we give the details about the NNs used in our paper. For clarification, We omit the ReLu activation here. However, in practice, we implement ReLu regularity. Also, for all convolution layers, we add padding to make sure there is no dimension reduction. We denote Conv(a,a,b) as a convolution layer having b channels with a by a filters, MP(a,a) as a a by a max-pooling layer, FN(a) as a fully-connect layer with a output and SM(a) is the soft-max layer with a output. For our Conv(5,5,b) (Conv (3,3,b))layers, the stride is 2 (1). See Table 6 for details of all models used in this paper.  Although second order adversarial attack looks well for MNIST (see Table 3), but for most our experiments on CIFAR-10 (see Table 4), the second order methods are weaker than variations of the gradient based methods. Also, notice that the robust models trained by second order method are also more prone to attack on CIFAR-10, particularly M F HSM and M L2HESS . We give two potential explanation here.
First note that the Hessian w.r.t. input is a low rank matrix. In fact, as mentioned above, the rank of the input Hessian for CIFAR-10 is at most ten; see Proposition 2, the matrix itself is 3K × 3K. Even though we use inexact Newton method [11] along with Conjugate Gradient solver, but this low rank nature creates numerical problems. Designing preconditioners for second-order attack is part of our future work. The second point is that, as we saw in the previous section the input Hessian does not directly correlate with how robust the network is. In fact, the most effective attack method would be to perturb the input towards the decision boundary, instead of just maximizing the loss.

A.5 More Numerical Result for §2 and 3
In this section, we provide more numerical results for §2 and 3. All conclusions from the numerical results are consistency with those in §2 and 3.  -5). We shows the Hessian spectrum of different batch training models, and the corresponding performances on adversarial dataset generated by training/testing dataset. The testing results are shown in parenthesis. We report the adversarial accuracy of three different magnitudes of attack. The interesting observation is that the λ θ 1 is increasing while the adversarial accuracy is decreasing for fixed . Meanwhile, we do not know if there is a relationship between λ θ 1 and Clean accuracy or not. Also, we cannot see the relation between λ x 1 , ∇ x J (θ, x, y) and the adversarial accuracy.

Cross Entropy
L2Hess Figure 9: We show the landscape of the test and training objective functional along the first eigenvector of the sub-sampled Hessian with B = 320, i.e. 320 samples from training, on CIFAR-10 for C3. We plot both the batch loss as well as the total training and test loss. One can see that visually the results show that the curvature of robust models is smaller. We report two cases for the single batch experiment, which is drawn randomly from the clean training data. The results show that the sub-sampled Hessian spectrum decreases for robust models. An interesting observation is that for the MNIST dataset, the original model has actually converged to a saddle point, even though it has a good generalization error. Also notice that the results for B = 320 and B = 60, 000 are relatively close, which hints that the curvature for the full Hessian should also be smaller for the robust methods. This is demonstrated in Fig. 8. Table 8: Baseline accuracy is shown for large batch size for C1 model along with results aciheved with scaling learning rate method proposed by [17] (denoted by "FB Acc"). The last column shows results when training is performed with robust optimization. As we can see, the performance of the latter is actually better for large batch size. We emphasize that the goal is to perform analysis to better understand the problems with large batch size training. More extensive tests are needed before one could claim that robust optimization performs better than other methods.
Batch Baseline Acc FB Acc Robust Acc  Figure 16: Changes in the dominant eigenvalue of the Hessian w.r.t weights and the total gradient is shown for different epochs during training. Note the increase in λ θ 1 (blue curve) for large batch vs small batch. In particular, note that the values for total gradient along with the Hessian spectrum show that large batch does not get "stuck" in saddle points, but areas in the optimization landscape that have high curvature. The dotted points show the corresponding results when we use robust optimization. We can see that this pushes the training to flatter areas. This clearly demonstrates the potential to use robust optimization as a means to avoid sharp minimas.