Title: DEEP FRANK-WOLFE FOR NEURAL NETWORK OPTIMIZATION

Abstract: Learning a deep neural network requires solving a challenging optimization problem: it is a high-dimensional, non-convex and non-smooth minimization problem with a large number of terms. The current practice in neural network optimization is to rely on the stochastic gradient descent (SGD) algorithm or its adaptive variants. However, SGD requires a hand-designed schedule for the learning rate. In addition, its adaptive variants tend to produce solutions that generalize less well on unseen data than SGD with a hand-designed schedule. We present an optimization method that offers empirically the best of both worlds: our algorithm yields good generalization performance while requiring only one hyper-parameter. Our approach is based on a composite proximal framework, which exploits the compositional nature of deep neural networks and can leverage powerful convex optimization algorithms by design. Specifically, we employ the Frank-Wolfe (FW) algorithm for SVM, which computes an optimal step-size in closed-form at each time-step. We further show that the descent direction is given by a simple backward pass in the network, yielding the same computational cost per iteration as SGD. We present experiments on the CIFAR and SNLI data sets, where we demonstrate the significant superiority of our method over Adam, Adagrad, as well as the recently proposed BPGrad and AMSGrad. Furthermore, we compare our algorithm to SGD with a hand-designed learning rate schedule, and show that it provides similar generalization while often converging faster. The code is publicly available at https://github.com/oval-group/dfw.

1. INTRODUCTION:

Since the introduction of back-propagation (Rumelhart et al., 1986) , stochastic gradient descent (SGD) has been the most commonly used optimization algorithm for deep neural networks. While yielding remarkable performance on a variety of learning tasks, a downside of the SGD algorithm is that it requires a schedule for the decay of its learning rate. In the convex setting, curvature properties of the objective function can be used to design schedules that are hyper-parameter free and guaranteed to converge to the optimal solution (Bubeck, 2015) . However, there is no analogous result of practical interest for the non-convex optimization problem of a deep neural network. An illustration of this issue is the diversity of learning rate schedules used to train deep convolutional networks with SGD: Simonyan & Zisserman (2015) and He et al. (2016) adapt the learning rate according to the validation performance, while Szegedy et al. (2015) , Huang et al. (2017) and Loshchilov & Hutter (2017) use pre-determined schedules, which are respectively piecewise constant, geometrically decaying, and cyclic with a cosine annealing. While these protocols result in competitive or state-of-the-art results on their learning task, there does not seem to be a consistent methodology. As a result, finding such a schedule for a new setting is a time-consuming and computationally expensive effort.

To alleviate this issue, adaptive gradient methods have been developed (Zeiler, 2012 , Kingma & Ba, 2015 , Reddi et al., 2018) , and borrowed from online convex optimization (Duchi et al., 2011) . Typically, these methods only require the tuning of the initial learning rate, the other hyper-parameters being considered robust across applications. However, it has been shown that such adaptive gradient methods obtain worse generalization than SGD (Wilson et al., 2017) . This observation is corroborated by our experimental results.

In order to bridge this performance gap between existing adaptive methods and SGD, we introduce a new optimization algorithm, called Deep Frank-Wolfe (DFW) . The DFW algorithm exploits the composite structure of deep neural networks to design an optimization algorithm that leverages efficient convex solvers. In more detail, we consider a composite (nested) optimization problem, with the loss as the outer function and the function encoded by the neural network as the inner one. At each iteration, we define a proximal problem with a first-order approximation of the neural network (linearized inner function), while keeping the loss function in its exact form (exact outer function). When the loss is the hinge loss, each proximal problem created by our formulation is exactly a linear SVM. This allows us to employ the powerful Frank-Wolfe (FW) algorithm as the workhorse of our procedure.

There are two by-design advantages to our method compared to the SGD algorithm. First, each iteration exploits more information about the learning objective, while preserving the same computational cost as SGD. Second, an optimal step-size is computed in closed-form by using the FW algorithm in the dual (Frank & Wolfe, 1956 , Lacoste-Julien et al., 2013) . Consequently, we do not need a hand-designed schedule for the learning rate. As a result, our algorithm is the first to provide competitive generalization error compared to SGD, all the while requiring a single hyper-parameter and often converging significantly faster.

We present two additional improvements to customize the use of the DFW algorithm to deep neural networks. First, we show how to smooth the loss function to avoid optimization difficulties arising from learning deep models with SVMs (Berrada et al., 2018) . Second, we incorporate Nesterov momentum (Nesterov, 1983) to accelerate our algorithm.

We demonstrate the efficacy of our method on image classification with the CIFAR data sets (Krizhevsky, 2009) using two architectures: wide residual networks (Zagoruyko & Komodakis, 2016) and densely connected convolutional neural networks (Huang et al., 2017) ; we also provide experiments on natural language inference with a Bi-LSTM on the SNLI corpus (Bowman et al., 2015) . We show that the DFW algorithm often strongly outperforms previous methods based on adaptive learning rates. Furthermore, it provides comparable or better accuracy to SGD with hand-designed learning rate schedules.

In conclusion, our contributions can be summed up as follows:

• We propose a proximal framework which preserves information from the loss function.

• For the first time for deep neural networks, we demonstrate how our formulation gives at each iteration (i) an optimal step-size in closed form and (ii) an update at the same computational cost as SGD.

• We design a novel smoothing scheme for the dual optimization of SVMs.

• To the best of our knowledge, the resulting DFW algorithm is the first to offer comparable or better generalization to SGD with a hand-designed schedule on the CIFAR data sets, all the while converging several times faster and requiring only a single hyperparameter.

do not require such a schedule, by either modifying the descent direction or adaptively rescaling the step-size (Duchi et al., 2011 , Zeiler, 2012 , Schaul et al., 2013 , Kingma & Ba, 2015 , Zhang et al., 2017b , Reddi et al., 2018) . However, as noted above, the adaptive variants of SGD sometimes provide subpar generalization (Wilson et al., 2017) .

Learning to Learn and Meta-Learning. Learning to learn approaches have also been proposed to optimize deep neural networks. Baydin et al. (2018) and Wu et al. (2018) learn the learning rate to avoid a hand-designed schedule and to improve practical performance. Such methods can be combined with our proposed algorithm to learn its proximal coefficient, instead of considering it as a fixed hyper-parameter to be tuned. Meta-learning approaches have also been suggested to learn the optimization algorithm (Andrychowicz et al., 2016 , Ravi & Larochelle, 2017 , Wichrowska et al., 2017 , Li & Malik, 2017) . This line of work, which is orthogonal to ours, could benefit from the use of DFW to optimize the meta-learner.

Optimization and Generalization. Several works study the relationship between optimization and generalization in deep learning. In order to promote generalization within the optimization algorithm itself, Neyshabur et al. (2015; 2016) proposed the Path-SGD algorithm, which implicitly controls the capacity of the model. However, their method required the model to employ ReLU non-linearity only, which is an important restriction for practical purposes. Hardt et al. (2016) , Arpit et al. (2017 ), Neyshabur et al. (2017 ), Hoffer et al. (2017) and Chaudhari & Soatto (2018) analyzed how existing optimization algorithms implicitly regularize deep neural networks. However this phenomenon is not yet fully understood, and the resulting empirical recommendations are sometimes opposing (Hardt et al., 2016 , Hoffer et al., 2017) .

Proximal Methods. The back-propagation algorithm has been analyzed in a proximal framework in (Frerix et al., 2018 ). Yet, the resulting approach still requires the same hyper-parameters as SGD and incurs a higher computational cost per iteration.

Linear SVM Sub-Problems. A main component of our formulation is to formulate sub-problems as linear SVMs. In an earlier work (Berrada et al., 2017) , we showed that neural networks with piecewise linear activations could be trained with the CCCP algorithm (Yuille & Rangarajan, 2002) , which yielded approximate SVM problems to be solved with the BCFW algorithm (Lacoste-Julien et al., 2013) . However this algorithm only updates the parameters of one layer at a time, which slows down convergence significantly in practice. Closest to our approach are the works of (Hochreiter & Obermayer, 2005) and (Singh & Shawe-Taylor, 2018) . Hochreiter & Obermayer (2005) suggested to create a local SVM based on a first-order Taylor expansion and a proximal term, in order to lower the error of every data sample while minimizing the changes in the weights. However their method operated in a non-stochastic setting, making the approach infeasible for large-scale data sets. Singh & Shawe-Taylor (2018) , a parallel work to ours, also created an SVM problem using a first-order Taylor expansion, this time in a mini-batch setting. Their work provided interesting insights from a statistical learning theory perspective. While their method is well-grounded, its significantly higher cost per iteration impairs its practical speed and scalability. As such, it can be seen as complementary to our empirical work, which exploits a powerful solver and provides state-of-the-art scalability and performance.

3. PROBLEM FORMULATION:

Before describing our formulation, we introduce some necessary notation. We use • to denote the Euclidean norm. Given a function φ, ∂φ(u) û is the derivative of φ with respect to u evaluated at û. According to the situation, this derivative can be a gradient, a Jacobian or even a directional derivative. Its exact nature will be clear from context throughout the paper. We also introduce the first-order Taylor expansion of φ around the point û:

T ûφ(u) = φ(û) + (∂φ(u) û) (u -û).

For a positive integer p, we denote the set {1, 2, ..., p} as [p] . For simplicity, we assume that stochastic algorithms process only one sample at each iteration, although the methods can be trivially extended to mini-batches of size larger than one.

3.1. LEARNING OBJECTIVE:

We suppose we are given a data set (x i , y i ) i∈ [N ] , where each x i ∈ R d is a sample annotated with a label y i from the output space Y. The data set is used to estimate a parameterized model represented by the function f . Given its (flattened) parameters w ∈ R p , and an input x i ∈ R d , the model predicts f (w, x i ) ∈ R |Y| , a vector with one score per element of the output space Y. For instance, f can be a linear map or a deep neural network. Given a vector of scores per label s ∈ R |Y| , we denote by L(s, y i ) the loss function that computes the risk of the prediction scores s given the ground truth label y i . For example, the loss L can be cross-entropy or the multi-class hinge loss:

(Cross-Entropy Loss)

EQUATION

(Multi-Class Hinge Loss)

L hinge : (s, y) ∈ R |Y| ×Y → max max k∈Y\{y} {s k + 1 -s y } , 0 . (2)

The cross-entropy loss (1) tries to match the empirical distribution by driving incorrect scores as far as possible from the ground truth one. The hinge loss (2) attempts to create a minimal margin of one between correct and incorrect scores. The hinge loss has been shown to be more robust to over-fitting than cross-entropy, when combined with smoothing techniques that are common in the optimization literature (Berrada et al., 2018) . To simplify notation, we introduce

f i (w) = f (w, x i ) and L i (s) = L(s, y i ) for each i ∈ [N ]

. Finally, we denote by ρ(w) the regularization (typically the squared Euclidean norm). We now write the learning problem under its empirical risk minimization form:

EQUATION

3.2. A PROXIMAL APPROACH:

Our main contribution is a formulation which exploits the composite nature of deep neural networks in order to obtain a better approximation of the objective at each iteration. Thanks to the careful approximation design, this approach yields sub-problems that are amenable to efficient optimization by powerful convex solvers. In order to understand the intuition of our approach, we first present a proximal gradient perspective on SGD.

The SGD Algorithm. At iteration t, the SGD algorithm selects a sample j at random and observes the objective estimate ρ(w t ) + L j (f j (w t )). Then, given the learning rate η t , it performs the following update on the parameters:

EQUATION

Equation ( 4) is the closed-form solution of a proximal problem where the objective has been linearized by the first-order Taylor expansion T wt (Bubeck, 2015) :

EQUATION

To see the relationship between (4) and (5), one can set the gradient with respect to w to 0 in equation ( 5), and observe that the resulting equation is exactly (4). In other words, SGD minimizes a first-order approximation of the objective, while encouraging proximity to the current estimate w t .

However, one can also choose to linearize only a part of the composite objective (Lewis & Wright, 2016) . Choosing which part to approximate is a crucial decision, because it yields optimization problems with widely different properties. In this work, we suggest an approach that lends itself to fast optimization with robust convex solvers and preserves information about the learning task by keeping an exact loss function.

Loss-Preserving Linearization. In detail, at iteration t, with selected sample j, we introduce the proximal problem that linearizes the regularization ρ and the model f j , but not the loss function L:

EQUATION

)

w t w * Φ(w * ) Original Objective Φ Linearization (SGD)

Loss-Preserving Linearization (LPL)

w t w * w SGD t+1 w LPL t+1 Φ(w * )

Original Objective Φ Proximal Objective (SGD, eq. ( 5))

Proximal Objective (LPL, eq. ( 6))

Figure 1 : We illustrate the different approximations on a synthetic composite objective function Φ(w) = L(f (w)) (Φ is plotted in black). In this example, L is a maximum of linear functions (similarly to a hinge loss) and f is a non-linear smooth map. We denote the current iterate by w t , and the point minimizing Φ by w * . On the left-hand side, one can observe how the SGD approximation is a single line (tangent at Φ(w t ), in blue), while the LPL approximation is piecewise linear (in orange), and thus matches the objective curve (in black) more closely. On the right-hand side, an identical proximal term is added to both approximations to visualize equations ( 5) and ( 6). Thanks to the better accuracy of the LPL approximation, the iterate w LPL t+1 gets closer to the solution w * than w SGD t+1 . This effect is particularly true when the proximal coefficient 1 2ηt is small, or equivalently, when the learning rate η t is large. Indeed, the accuracy of the local approximation becomes more important when the proximal term is contributing less (e.g. when η t is large).

In figure 1 , we provide a visual comparison of equations ( 5) and ( 6) in the case of a piecewise linear loss. As will be seen, by preserving the loss function, we will be able to achieve good performance across a number of tasks with a fixed η t = η. Consequently, we will provide the first algorithm to accurately learn deep neural networks with only a single hyper-parameter while offering similar performance compared to SGD with a hand-designed schedule.

4. THE DEEP FRANK-WOLFE ALGORITHM:



4.1. ALGORITHM:

We focus on the optimization of equation ( 6) when L is a multi-class hinge loss (2). The results of this section were originally derived for linear models (Lacoste-Julien et al., 2013) . Our contribution is to show for the first time how they can be exploited for deep neural networks thanks to our formulation (6). We will refer to the resulting algorithm for neural networks as Deep Frank-Wolfe (DFW). We begin by stating the key advantage of our method.

Proposition 1 (Optimal step-size, (Lacoste-Julien et al., 2013) ). Problem (6) with a hinge loss is amenable to optimization with Frank-Wolfe in the dual, which yields an optimal step-size γ t ∈ [0, 1] in closed-form at each iteration t.

This optimal step-size can be obtained in closed-form because the hinge loss is convex and piecewise linear. In fact, the approach presented here can be applied to any loss function L that is convex and piecewise linear (another example would be the l 1 distance for regression for instance).

Since the step-size can be computed in closed-form, the main computational challenge is to obtain the update direction, that is, the conditional gradient of the dual. In the following result, we show that by taking a single step per proximal problem, this dual conditional gradient can be computed at the same cost as a standard stochastic gradient. The proof is available in appendix A.5.

Proposition 2 (Cost per iteration). If a single step is performed on the dual of ( 6), its conditional gradient is given by -∂ (ρ(w) + L y (f x (w))) wt . Given the step-size γ t , the resulting update can be written as:

EQUATION

In other words, the cost per iteration of the DFW algorithm is the same as SGD, since the update only requires standard stochastic gradients. In addition, we point out that in a mini-batch setting, the conditional gradient is given by the average of the gradients over the mini-batch. As a consequence, we can use batch Frank-Wolfe in the dual rather than coordinate-wise updates, with the same parallelism as SGD over the samples of a mini-batch.

One can observe how the update (7) exploits the optimal step-size γ t ∈ [0, 1] given by Proposition 1. There is a geometric interpretation to the role of this step-size γ t . When γ t is set to its minimal value 0, the resulting iterate does not move along the direction ∂L j (f j (w)) wt . Since the step-size is optimal, this can only happen if the current iterate is detected to be at a minimum of the piecewise linear approximation. Conversely, when γ t reaches its maximal value 1, the algorithm tries to move as far as possible along the direction ∂L j (f j (w)) wt . In that case, the update is the same as the one obtained by SGD (as given by equation ( 4)). In other words, γ t can automatically decay the effective learning rate, hereby preventing the need to design a learning rate schedule by hand.

As mentioned previously, the DFW algorithm performs only one step per proximal problem. Since problem ( 6) is only an approximation of the original problem (3), it may be unnecessarily expensive to solve it very accurately. Therefore taking a single step per proximal problem may help the DFW algorithm to converge faster. This is confirmed by our experimental results, which show that DFW is often able to minimize the learning objective (3) at greater speed than SGD.

4.2. IMPROVEMENTS FOR DEEP NEURAL NETWORKS:

We present two improvements to customize the application of our algorithm to deep neural networks.

Smoothing. The SVM loss is non-smooth and has sparse derivatives, which can cause difficulties when training a deep neural network (Berrada et al., 2018) . In Appendix A.6, we derive a novel result that shows how we can exploit the smooth primal cross-entropy direction and inexpensively detect when to switch back to using the standard conditional gradient.

Nesterov Momentum. To take advantage of acceleration similarly to the SGD baseline, we adapt the Nesterov momentum to the DFW algorithm. We defer the details to the appendix in A.7 for space reasons. We further note that the momentum coefficient µ is typically set to a high value, say 0.9, and does not contribute significantly to the computational cost of cross-validation.

4.3. ALGORITHM SUMMARY:

The main steps of DFW are shown in Algorithm 1. As the key feature of our approach, note that the step-size is computed in closed-form in step 10 of the algorithm (colored in blue).

Note that only the hyper-parameter η will be tuned in our experiments: we will use the same batch-size, momentum and number of epochs as the baselines in our experiments (unless specified otherwise). In addition, we point out again that when γ t = 1, we recover the SGD step with Nesterov momentum.

In sections A.5 and A.6 of the appendix, we detail the derivation of the optimal step-size (step 10) and the computation of the search direction (step 7). The computation of the dual search direction is omitted here for space reasons. However, its implementation is straightforward in practice, and its computational cost is linear in the size of the output space.

Finally, we emphasize that the DFW algorithm is motivated by an empirical perspective. While our method is not guaranteed to converge, our experiments show an effective minimization of the learning objective for the problems encountered in practice.

Algorithm 1 The Deep Frank-Wolfe Algorithm:

Require: proximal coefficient η, initial point w 0 ∈ R p , momentum coefficient µ, number of epochs 1: t = 0 2: z 0 = 0 Momentum velocity (initialization) 3: for each epoch do Receive data of mini-batch

(x i , y i ) i∈B 6: ∀i ∈ B, b (i) t (w t ) = (f xi,ȳ (w t ) -f xi,yi (w t ) + ∆(ȳ, y i )) ȳ∈Y Forward pass 7: ∀i ∈ B, s (i) t ← get_s(b (i) t (w t ))

Dual direction (details in Appendix A.6) 8: 

δ t = ∂ 1 |B| i∈B (s (i) t ) b (i) t (

γ t = (-ηδ t r t + 1 |B| i∈B (s (i) t ) b (i) t (w t )/(η δ t 2 ) clipped to [0, 1]

Step-size 11:

z t+1 = µz t -ηγ t (r t + δ t )

Velocity accumulation 12:

w t+1 = w t -η [r t + γ t δ t ] + µz t+1

Parameters update 13:

t = t + 1 14:

end for 15: end for SGD at a lower computational cost, even though SGD has the advantage of a hand-designed schedule that has been chosen separately for each of these tasks.

Our experiments are implemented in pytorch (Paszke et al., 2017) , and the code is available at https://github.com/oval-group/dfw. All models are trained on a single Nvidia Titan Xp card.

5.1. IMAGE CLASSIFICATION WITH CONVOLUTIONAL NEURAL NETWORKS:

Data Set & Architectures. The CIFAR-10/100 data sets contain 60,000 RGB natural images of size 32 × 32 with 10/100 classes (Krizhevsky, 2009) . We split the training set into 45,000 training samples and 5,000 validation samples, and use 10,000 samples for testing. The images are centered and normalized per channel. Unless specified otherwise, no data augmentation is employed. We perform our experiments on two modern architectures of deep convolutional neural networks: wide residual networks (Zagoruyko & Komodakis, 2016) , and densely connected convolutional networks (Huang et al., 2017) . Specifically, we employ a wide residual network of depth 40 and width factor 4, which has 8.9M parameters, and a "bottleneck" densely connected convolutional neural network of depth 40 and growth factor 40, which has 1.9M parameters. We refer to these architectures as WRN and DN respectively. All the following experimental details follow the protocol of (Zagoruyko & Komodakis, 2016) and (Huang et al., 2017) . The only difference is that, instead of using 50,000 samples for training, we use 45,000 samples for training, and 5,000 samples for the validation set, which we found to be essential for all adaptive methods. While Deep Frank Wolfe (DFW) uses an SVM loss, the baselines are trained with the Cross-Entropy (CE) loss since this resulted in better performance.

Method. We compare DFW to the most common adaptive learning rates currently used: Adagrad (Duchi et al., 2011 ), Adam (Kingma & Ba, 2015) , the corrected version of Adam called AMSGrad (Reddi et al., 2018) , and BPGrad (Zhang et al., 2017b) . For these methods and for DFW, we cross-validate the initial learning rate as a power of 10. We also evaluate the performance of SGD with momentum (simply referred to as SGD), for which we follow the protocol of (Zagoruyko & Komodakis, 2016) and (Huang et al., 2017) . For all methods, we set a budget of 200 epochs for WRN and 300 epochs for DN. Furthermore, the batch-size is respectively set to 128 and 64 for WRN and DN as in (Zagoruyko & Komodakis, 2016) and (Huang et al., 2017) . For DN, the l 2 regularization is set to 10 -4 as in (Huang et al., 2017) . For WRN, the l 2 is cross-validated between 5.10 -4 , as in (Zagoruyko & Komodakis, 2016) , and 10 -4 , a more usual value that we have found to perform better for some of the methods (in particular DFW, since the corresponding loss function is an SVM instead of CE, for which the value of 5.10 -4 was designed). The value of the Nesterov momentum is set to 0.9 for BPGrad, SGD and DFW. DFW has only one hyper-parameter to tune, namely η, which is analogous to an initial learning rate. For SGD, the initial learning rate is set to 0.1 on both WRN and DN. Following (Zagoruyko & Komodakis, 2016) and (Huang et al., 2017) , it is then divided by 5 at epochs 60, 120 and 180 for WRN, and by 10 at epochs 150 and 225 for DN.

Results. We present the results in Table 1 In black, all adaptive methods have a single hyper-parameter for their step-size. In red, SGD benefits from a hand-designed schedule. DFW outperforms all baselines on the WRN architecture, by a margin of 7% for adaptive gradient methods on CIFAR-100. On the DN-100 task, DFW exceeds the accuracy of Adagrad by 14%.

Observe that DFW significantly outperforms the adaptive gradient methods, particularly on the more challenging CIFAR-100 data set. On the WRN-CIFAR-100 task in particular, DFW obtains a testing accuracy which is about 7% higher than all other adaptive methods and outperforms SGD with a hand-designed schedule by 1%. The inferior generalization of adaptive gradient methods is consistent with the findings of Wilson et al. (2017) . On all tasks, the accuracy of DFW is comparable to SGD. Note that DFW converges significantly faster than SGD: the network reaches its final performance several times faster than SGD in all cases. We illustrate this with an example in figure 2 , which plots the training and validation errors on DN-CIFAR-100. In figure 3 , one can see how the step-size is automatically decayed by DFW on this same experiment: we compare the effective step-size γ t η for DFW to the manually tuned η t for SGD. Step-Size

SGD DFW:

Figure 3 : The (automatic) evolution of γ t η for the DFW algorithm compared to the "staircase" hand-designed schedule of η t for SGD.

Data Augmentation. Since data augmentation provides a significant boost to the final accuracy, we provide additional results that make use of it. Specifically, we randomly flip the images horizontally and randomly crop them with four pixels padding. For methods that do not use a hand-designed schedule, such data augmentation introduces additional variance which makes the adaptation of the step-size more difficult. Therefore we allow the batch size of adaptive methods (e.g. all methods but SGD) to be chosen as 1x, 2x or 4x, where x is the original value of batch-size (64 for DN, 128 for WRN). Due to the heavy computational cost of the cross-validation (we tune the batch-size, regularization and initial learning rate), we provide results for SGD, DFW and the best performing adaptive gradient method, which is AMSGrad. For SGD the hyper-parameters are kept the same as in (Zagoruyko & Komodakis, 2016) and (Huang et al., 2017) . We present the results in In black, all adaptive methods have a single hyper-parameter for their step-size. In red, SGD benefits from a hand-designed schedule. On the fourth line, SGD * refers to the result reported in Table 5 of (Huang et al., 2017) . The small difference between the results of SGD and SGD * can be explained by the fact that we use 5,000 fewer training samples in our experiments (these are kept for validation). The results of this table show that DFW systematically outperforms AMSGrad on this task (by up to 7% on WRN-100).

These results confirm that DFW consistently outperforms AMSGrad, which is the best adaptive baseline on these tasks. In particular, DFW obtains a test accuracy which is 7% better than AMSGrad on WRN-100.

5.2. NATURAL LANGUAGE INFERENCE WITH RECURRENT NEURAL NETWORKS:

Data Set. The Stanford Natural Language Inference (SNLI) data set is a large corpus of 570k pairs of sentences (Bowman et al., 2015) . Each sentence is labeled by one of the three possible labels: entailment, neutral and contradiction. This allows the model to learn the semantics of the text data from a three-way classification problem. Thanks to its scale and its supervised labels, this data set allows large neural networks to learn high-quality text embeddings. As Conneau et al. (2017) demonstrate, the SNLI corpus can thus be used as a basis for transfer learning in natural language processing, in the same way that the ImageNet data set is used for pre-training in computer vision.

Method. We follow the protocol of (Conneau et al., 2017) to learn their best model, namely a bi-directional LSTM of about 47M parameters. In particular, the reported results use SGD with an initial learning rate of 0.1 and a hand-designed schedule that adapts to the variations of the validation set: if the validation accuracy does not improve, the learning rate is divided by a factor of 5. We also report results on Adagrad, Adam, AMSGrad and BPGrad. Following the official SGD baseline, Nesterov momentum is deactivated. Using their open-source implementation, we replace the optimization by the DFW algorithm, the CE loss by an SVM, and leave all other components unchanged. In this experiment, we use the conditional gradient direction rather than the CE gradient, since three-way classification does not cause sparsity in the derivative of the hinge loss (which is the issue that originally motivated our use of a different direction). We cross-validate our initial proximal term as a power of ten, and do not manually tune any schedule. In order to disentangle the importance of the loss function from the optimization algorithm, we run the baselines with both an SVM loss and a CE loss. The initial learning rate of the baselines is also cross-validated as a power of ten.

Results. The results are presented in In black, all adaptive methods have a single hyper-parameter for their step-size. In red, SGD benefits from a hand-designed schedule. SGD * refers to the result reported in (Conneau et al., 2017) . The other results have been obtained with their open-source implementation in our own experiments.

Note that these results outperform the reported testing accuracy of 84.5% in (Conneau et al., 2017) that is obtained with CE. This experiment, which is performed on a completely different architecture and data set than the previous one, confirms that DFW outperforms adaptive gradient methods and matches the performance of SGD with a hand-designed learning rate schedule.

6 THE IMPORTANCE OF THE STEP-SIZE

6.1. IMPACT ON GENERALIZATION:

It is worth discussing the subtle relationship between optimization and generalization. In order to emphasize the impact of implicit regularization, all results presented in this section do not use data augmentation. As a first illustrative example, we consider the following experiment: we take the protocol to train the DN network on CIFAR-100 with SGD, and simply change the initial learning rate to be ten times smaller, and the budget of epochs to be ten times larger. As a result, the final training objective significantly decreases from 0.33 to 0.069. Yet at the same time, the best validation accuracy decreases from 70.94% to 68.7%. A similar effect occurs when decreasing the value of the momentum, and we have observed this across various convolutional architectures. In other words, accurate optimization is less important for generalization than the implicit regularization of a high learning rate.

We have observed DFW to accurately optimize the learning objective in our experiments. However, given the above observation, we believe that its good generalization properties are rather due to its capability to usually maintain a high learning rate at an early stage. Similarly, the good generalization performance of SGD may be due to its schedule with a large number of steps at a high learning rate.

6.2. SENSITIVITY ANALYSIS:

The previous section has qualitatively hinted at the importance of the step-size for generalization.

Here we quantitatively analyze the impact of the initial learning rate η on both the training accuracy (quality of optimization) and the validation accuracy (quality of generalization). We compare results of the DFW and SGD algorithms on the CIFAR data sets when varying the value of η as a power of 10. The results on the validation set are summarized in figure 4 , and the performance on the training set is reported in Appendix B.

On the training set, both methods obtain nearly perfect accuracy across at least three orders of magnitude of η (details in Appendix B.4). In contrast, the results of figure 4 confirm that the validation performance is sensitive to the choice of η for both methods.

In some cases where η is high, SGD obtains a better performance than DFW. This is because the handdesigned schedule of SGD enforces a decay of η, while the DFW algorithm relies on an automatic decay of the step-size γ t for effective convergence. This automatic decay may not happen if a small proximal term (large η) is combined with a local approximation that is not sufficiently accurate (for instance with a small batch-size).

However, if we allow the DFW algorithm to use a larger batch size, then the local approximation becomes more accurate and it can handle large values of η as well. Interestingly, choosing a larger batch-size and a larger value of η can result in better generalization. For instance, by using a batchsize of 256 (instead of 64) and η = 1, DFW obtains a test accuracy of 72.64% on CIFAR-100 with the DN architecture (SGD obtains 70.33% with the settings of (Huang et al., 2017) ). 

6.3. DISCUSSION:

Our empirical evidence indicates that the initial learning rate can be a crucial hyper-parameter for good generalization. We have observed in our experiments that such a choice of high learning rate provides a consistent improvement for convolutional neural networks: accurate minimization of the training objective with large initial steps usually leads to good generalization. Furthermore, as mentioned in the previous section, it is sometimes beneficial to even increase the batch-size in order to be able to train the model using large initial steps.

In the case of recurrent neural networks, however, this effect is not as distinct. Additional experiments on different recurrent architectures have showed variations in the impact of the learning rate and in the best-performing optimizer. Further analysis would be required to understand the effects at play.

7. CONCLUSION:

We have introduced DFW, an efficient algorithm to train deep neural networks. DFW predominantly outperforms adaptive gradient methods, and obtains similar performance to SGD without requiring a hand-designed learning rate schedule.

We emphasize the generality of our framework in Section 3, which enables the training of deep neural networks to benefit from any advance on optimization algorithms for linear SVMs. This framework could also be applied to other loss functions that yield efficiently solvable proximal problems. In particular, our algorithm already supports the use of structured prediction loss functions (Taskar et al., 2003 , Tsochantaridis et al., 2004) , which can be used, for instance, for image segmentation.

We have mentioned the intricate relationship between optimization and generalization in deep learning. This illustrates a major difficulty in the design of effective optimization algorithms for deep neural networks: the learning objective does not include all the regularization needed for good generalization. We believe that in order to further advance optimization for deep neural networks, it is essential to alleviate this problem and expose a clear objective function to optimize.

A PROOFS & ALGORITHMS:

For completeness, we prove results for our specific instance of Structural SVM problem. We point out that the proofs of sections A.1, A.2 and A.3 are adaptations from (Lacoste-Julien et al., 2013) . Propositions are numbered according to their appearance in the paper.

A.1 PRELIMINARIES:

In this section, we assume the loss L to be a hinge loss:

EQUATION

We suppose that we have received a sample (x, y). We simplify the notation f (w, x) = f x (w) and L(u, y) = L y (u). For simplicity of the notation, and without loss of generality, we consider the proximal problem obtained at time t = 0:

EQUATION

)

Let us define the classification task loss:

EQUATION

)

Using this notation, the multi-class hinge loss can be written as:

EQUATION

Indeed, we can successively write:

EQUATION

)

We are now going to re-write problem (9) as the sum of a quadratic term and a pointwise maximum of linear functions. For ȳ ∈ Y, let us define:

EQUATION

)

Then we have that:

EQUATION

)

Therefore, problem (9) can be written as:

EQUATION

)

We notice that the term ρ(w 0 ) in b is a constant that does not depend on w nor ȳ, therefore we can simplify the expression of b to:

EQUATION

We introduce the following notation:

EQUATION

EQUATION

EQUATION

We will also use the indicator vector: 1 y ∈ R |Y| , which is equal to 1 at index y and 0 elsewhere.

A.2 DUAL OBJECTIVE:

Lemma 1 (Dual Objective). The Lagrangian dual of ( 9) is given by:

EQUATION

Given the dual variables α, the primal can be computed as ŵ = -Aα.

Proof. We derive the Lagrangian of the primal problem. For that, we write the problem in the following equivalent ways:

EQUATION

EQUATION

EQUATION

sup α≥0 min ŵ∈R p ξ∈R    1 2η ŵ 2 + ξ + ȳ∈Y α ȳ a ȳ ŵ + b ȳ -ξ    Λ( ŵ,ξ,α)

(by strong duality).

We can now write the KKT conditions of the inner minimization problem:

EQUATION

This gives α ∈ P and ŵ = -Aα, since A = (ηa ȳ ) ȳ∈Y by definition. By injecting these constraints in (24), we obtain:

EQUATION

which finally gives the desired result.

A.3 DERIVATION OF THE OPTIMAL STEP-SIZE:

Lemma 2 (Optimal Step-Size). Suppose that we make a step in the direction of s ∈ P in the dual. We define the corresponding primal variables w s = -As and λ s = b s, as well as λ = b α. Then the optimal step-size is given by:

EQUATION

)

Proof. Given the direction s, we take the step α + γ(s -α). The new objective is given by:

-

EQUATION

In order to compute the optimal step-size, we compute the derivative of the above expression with respect to gamma, and set it to 0:

EQUATION

We can isolate the unique term containing γ:

EQUATION

This yields:

EQUATION

We can then inject the primal variables and simplify:

EQUATION

A.4 PRIMAL-DUAL PROXIMAL FRANK-WOLFE ALGORITHM

We present here the primal-dual algorithm that solves (9) using the previous results:

Algorithm 2 Proximal Frank Wolfe Algorithm Require: proximal coefficient η, initial point w 0 ∈ R p , sample (x, y). 1: w 1 = w 0 -η∂ρ(w) w0 Initialization w 0 -Aα with α = 1 y 2: λ 1 = 0 Initialization b α with α = 1 y 3: t = 1 4: while not converged do 5:

Choose direction s t ∈ P (e.g. conditional gradient or smoothed loss) 6:

w s = -As t 7: λ s = b s t 8: γ t = (w t -w 0 -w s ) (w t -w 0 ) + η(λ s -λ t ) w -w 0 -w s 2

Optimal-step-size 9:

w t+1 = (1 -γ t )w t + γ t (w s + w 0 ) Aα t+1 = (1 -γ t )Aα t + γ t As t 10: λ t+1 = (1 -γ t )λ t + γ t λ s b α t+1 = (1 -γ t )b α t + γ t b s t 11:

t = t + 1 12: end while Note that when f x is linear, and when the search direction s is given by the conditional gradient, we recover the standard Frank-Wolfe algorithm for SVM (Lacoste-Julien et al., 2013) .

A.5 SINGLE-STEP PROXIMAL FRANK-WOLFE ALGORITHM:

We now provide some simplification to the steps 6, 8 and 9 of Algorithm 2 when a single step is taken, as is the case in the DFW algorithm. This corresponds to the iteration t = 1.

Proposition 2 (Cost per iteration). If a single step is performed on the dual of (6), its conditional gradient is given by -∂ (ρ(w) + L y (f x (w))) wt . The resulting update can be written as:

EQUATION

Proof. It is known that for linear SVMs, the direction of the dual conditional gradient is given by the negative sub-gradient of the primal (Lacoste-Julien et al., 2013 , Bach, 2015) . We apply this result to the Taylor expansion of the network, which is the local model used for the proximal problem. Then we have that at iteration t = 1, the conditional gradient is given by:

EQUATION

It now suffices to notice that a first-order Taylor expansion does not modify the derivative at its point of linearization: for a function φ, ∂T w0 φ(w) w0 = ∂φ(w) w0 . By applying this property and the chain rule to (34), we obtain that the conditional gradient is given by:

EQUATION

This completes the proof that the conditional gradient direction is given by a stochastic gradient. We now prove equation ( 33) in the next lemma.

Lemma 3. Suppose that we apply the Proximal Frank-Wolfe algorithm with a single step. Let δ t = ∂ s t (f x,ȳ (w 0 ) -f x,y (w 0 )) ȳ∈Y and r t = ∂ w ρ(w 0 ). Then we can rewrite step 6 as:

EQUATION

In addition, we can simplify steps 8 and 9 of Algorithm 2 to:

EQUATION

EQUATION

Proof. Again, since we perform a single step of FW, we assume t = 1. To prove equation ( 36), we note that:

EQUATION

We point out the two following results:

EQUATION

and: w t -w 0 -w s = -ηr t + ηr t + ηδ t = ηδ t .

(41) Since λ 1 = 0 by definition, equation ( 37) is obtained with a simple application of equations 40 and 41. Finally, we prove equation 38 by writing:

EQUATION

A.6 SMOOTHING THE LOSS As pointed out in the paper, the SVM loss is non-smooth and has sparse derivatives, which can prevent the effective training of deep neural networks (Berrada et al., 2018) . Partial linearization can solve this problem by locally smoothing the dual (Mohapatra et al., 2016) . However, this would introduce a temperature hyper-parameter which is undesirable. Therefore, we note that DFW can be applied with any direction that is feasible in the dual, since it computes an optimal step-size. In particular, the following result states that we can use the well-conditioned and non-sparse gradient of cross-entropy.

Proposition 3. The gradient of cross-entropy in the primal gives a feasible direction in the dual. Furthermore, we can inexpensively detect when this feasible direction cannot provide any improvement in the dual, and automatically switch to the conditional gradient when that is the case.

For simplicity, we divide Proposition 3 into two distinct parts: first we show how the CE gradient gives a feasible direction in the dual, and then how it can be detected to be an ascent direction.

Lemma 4. The gradient of cross-entropy in the primal gives a feasible direction in the dual. In other words, the gradient of cross-entropy g in the primal is such that there exists a dual search direction s ∈ P verifying g = -As.

Proof. We consider the vector of scores (f x,ȳ (w)) ȳ∈Y ∈ R |Y| . We compute its softmax: s ce = exp(fx,ȳ(w))

j∈Y exp(fx,j (w)) ȳ∈Y . Clearly, s ce ∈ P by property of the softmax. Furthermore, by going back to the definition of A, one can easily verify that -As ce is exactly the primal gradient given by a backward pass through the cross-entropy loss instead of the hinge loss. This concludes the proof.

The previous lemma has shown that we can use the gradient of cross-entropy as a feasible direction s ce in the dual. The next step is to make it a dual ascent direction, that is a direction which always permits improvement on the dual objective (unless at the optimal point). In what follows, we show that we can inexpensively (approximately) compute a sufficient condition for s ce to be an ascent direction. If the condition is not satisfied, then we can automatically switch to use the subgradient of the hinge loss (which is known as an ascent direction in the dual).

Lemma 5. Let s ∈ P be a feasible direction in the dual, and v = (T w0 f x (w t ) ȳ + ∆(ȳ, y) -T w0 f x (w t ) y ) ȳ∈Y ∈ R |Y| be the vector of augmented scores output by the linearized model. Let us assume that we apply the single-step Proximal Frank-Wolfe algorithm (that is, we have t = 1), and that ρ is a non-negative function. Then s v > 0 is a sufficient condition for s to be an ascent direction in the dual. Proof. Let s ∈ P, v = (T w0 f x (w t ) ȳ + ∆(ȳ, y) -T w0 f x (w t ) y ) ȳ∈Y . By definition, we have that:

EQUATION

Therefore:

s v > 0 ⇐⇒ 1 η (As) (w t -w 0 ) + s b -s (T w0 ρ(w)) ȳ∈Y > 0,

⇐⇒ (As) (w t -w 0 ) + ηs b -ηT w0 ρ(w) > 0, (since s ∈ P and η > 0)

⇐⇒ -w s (w t -w 0 ) + ηs b -ηρ(w 0 ) -η∂ρ(w 0 ) (w t -w 0 ) > 0, ⇐⇒ -w s (w t -w 0 ) + ηs b -ηρ(w 0 ) + (w t -w 0 ) (w t -w 0 ) > 0,

⇐⇒ (w t -w 0 -w s ) (w t -w 0 ) + ηs b -ηρ(w 0 ) > 0, =⇒ (w t -w 0 -w s ) (w t -w 0 ) + ηs b > 0, (because ρ(w 0 ) ≥ 0) ⇐⇒ γ t > 0 (we have that λ t = 0 at t = 1).

(44)

We have just shown that if s v > 0, then γ t > 0. Since γ t is an optimal step-size, this indicates that s is an ascent direction (we would obtain γ t = 0 for a direction s that cannot provide improvement). 

:

EXPERIMENTSWe compare the Deep Frank Wolfe (DFW) algorithm to the state-of-the-art optimizers. We show that, across diverse data sets and architectures, the DFW algorithm outperforms adaptive gradient methods (with the exception of one setting, DN-10, where it obtains similar performance to AMSGrad and BPGrad). In addition, the DFW algorithm offers competitive and sometimes superior performance to

Figures and Tables:

Figure 2: Training and validation error during the training of DN on CIFAR-100. DFW converges significantly faster than SGD.

Figure 4: Visualization of the sensitivity analysis for the choice of initial learning rate η on the CIFAR data sets. Each subplot displays the best validation accuracy for DFW and SGD. Similar plots are available in larger format in Appendix B.4.

Figure 5: Convergence plot of Adagrad on CI-FAR 100 with DN architecture.

Figure 11: Convergence plot of BPGrad on CI-FAR 100 with DN architecture.

Figure 12: Convergence plot of BPGrad on CI-FAR 10 with DN architecture.

Figure 13: Convergence plot of DFW on CIFAR 100 with DN architecture.

Figure 15: Convergence plot of SGD on CIFAR 100 with DN architecture.

Figure 16: Convergence plot of SGD on CIFAR 10 with DN

Figure 19: Convergence plot of Adam on CIFAR 100 with WRN architecture.

Figure 20: Convergence plot of Adam on CIFAR 10 with WRN architecture.

Figure 21: Convergence plot of AMSGrad on CIFAR 100 with WRN architecture.

Figure 23: Convergence plot of BPGrad on CI-FAR 100 with WRN architecture.

Figure 24: Convergence plot of BPGrad on CI-FAR 10 with WRN architecture.

Figure 27: Convergence plot of SGD on CIFAR 100 with WRN architecture.

Figure 28: Convergence plot of SGD on CIFAR 10 with WRN architecture.

. Results on the CIFAR data sets without data augmentation.

Table content: <table><tr><td colspan="2">Architecture Optimizer</td><td colspan="2">CIFAR-10 Test Accuracy (%) Test Accuracy (%) CIFAR-100</td></tr><tr><td>WRN DN</td><td>Adagrad Adam AMSGrad BPGrad DFW SGD Adagrad Adam AMSGrad BPGrad DFW SGD</td><td>86.07 84.86 86.08 88.62 90.18 90.08 87.32 88.44 90.53 90.85 90.22 92.02</td><td>57.64 58.46 60.73 60.31 67.83 66.78 56.47 64.61 68.32 59.36 69.55 70.33</td></tr></table>



Table content: <table><tr><td colspan="2">Architecture Optimizer</td><td colspan="2">CIFAR-10 Test Accuracy (%) Test Accuracy (%) CIFAR-100</td></tr><tr><td>WRN DN</td><td>AMSGrad DFW SGD SGD  *  AMSGrad DFW SGD</td><td>90.06 94.71 95.40 95.47 91.78 94.88 95.26</td><td>67.75 74.71 77.78 78.82 69.58 73.20 76.26</td></tr></table>

Results on the CIFAR data sets with data augmentation.

Table content: <table/>

OptimizerLoss Adagrad Adam AMSGrad BPGrad DFW SGD SGD *

Table content: <table><tr><td>Test Accuracy (%)</td><td>CE SVM</td><td>83.8 84.6</td><td>84.5 85.0</td><td>84.2 85.1</td><td>83.6 84.2</td><td>-85.2</td><td>84.7 85.2</td><td>84.5 -</td></tr></table>

Results on the Stanford Natural Language Inference corpus.

Table content: <table/>

Cross-Validation for ADAM on DN architecture (best validation accuracy obtained during training).

Table content: <table><tr><td colspan="4">B EXPERIMENTAL DETAILS ON THE CIFAR DATA SETS</td></tr><tr><td colspan="4">B.1 ADAPTIVE GRADIENT BASELINES: CROSS-VALIDATION (WITHOUT DATA AUGMENTATION)</td></tr><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.001</td><td>71.6</td><td>39.44</td></tr><tr><td colspan="2">0.0001 0.01 0.0001 0.1 0.0001 1</td><td>88.18 86.4 68.48</td><td>55.72 55.44 20.68</td></tr><tr><td colspan="4">Table 4: Cross-Validation for ADAGRAD on DN architecture (best validation accuracy obtained during training).</td></tr><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.001 0.0001 0.01 0.0001 0.1 0.0005 0.001 0.0005 0.01 0.0005 0.1</td><td>68.98 86.4 83.6 68.66 86.3 77.92</td><td>31.86 53.82 51.18 32.5 56.16 44.12</td></tr><tr><td colspan="4">Table 5: Cross-Validation for ADAGRAD on WRN architecture (best validation accuracy obtained during training).</td></tr><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.0001</td><td>86.26</td><td>50.7</td></tr><tr><td colspan="2">0.0001 0.001 0.0001 0.01</td><td>89.42 81.12</td><td>63.9 51.82</td></tr><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.0001</td><td>79.7</td><td>41.42</td></tr><tr><td colspan="2">0.0001 0.001 0.0001 0.01 0.0005 0.0001 0.0005 0.001 0.0005 0.01</td><td>86.1 80.06 78.88 85.14 72.54</td><td>58.7 50.86 40.08 55.26 36.82</td></tr></table>

Cross-Validation for ADAM on WRN architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.0001</td><td>84.28</td><td>49.54</td></tr><tr><td colspan="2">0.0001 0.001 0.0001 0.01</td><td>90.4 83.98</td><td>68.54 50.44</td></tr><tr><td colspan="4">Table 8: Cross-Validation for AMSGRAD on DN architecture (best validation accuracy obtained during training).</td></tr><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.0001</td><td>75.86</td><td>41.6</td></tr><tr><td colspan="2">0.0001 0.001 0.0001 0.01 0.0005 0.0001 0.0005 0.001 0.0005 0.01</td><td>87.02 82.32 75.74 86.16 75.82</td><td>59.6 52.12 42.28 57.82 36.48</td></tr></table>

Cross-Validation for AMSGRAD on WRN architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.001 0.0001 0.01</td><td>72.72 83.26</td><td>40.96 53.12</td></tr><tr><td>0.0001 0.0001</td><td>0.1 1</td><td>91.7 10.16</td><td>59.7 1.16</td></tr></table>

Cross-Validation for BPGRAD on DN architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>l 2</td><td>η</td><td colspan="2">Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.001 0.0001 0.01 0.0001 0.1 0.0001 1 0.0005 0.001 0.0005 0.01 0.0005 0.1 0.0005 1</td><td>64.98 78.46 89.24 16.1 68.08 85.44 88.44 10.16</td><td>31.9 44.26 54.42 1.16 33.26 59.9 51.28 1.16</td></tr><tr><td colspan="4">Table 11: Cross-Validation for BPGRAD on WRN architecture (best validation accuracy obtained during training).</td></tr></table>

Cross-Validation for AMSGRAD on DN architecture with data augmentation (best validation accuracy obtained during training).

Table content: <table><tr><td>l 2</td><td>η</td><td colspan="3">batchsize Accuracy CIFAR-10 (%) Accuracy CIFAR-100 (%)</td></tr><tr><td colspan="2">0.0001 0.0001 0.0001 0.0001 0.0001 0.0001 0.0001 0.001 0.0001 0.001 0.0001 0.001 0.0001 0.01 0.0001 0.01 0.0001 0.01 0.0005 0.0001 0.0005 0.0001 0.0005 0.0001 0.0005 0.001 0.0005 0.001 0.0005 0.001 0.0005 0.01 0.0005 0.01 0.0005 0.01</td><td>128 256 512 128 256 512 128 256 512 128 256 512 128 256 512 128 256 512</td><td>90.5 89.6 88.26 91.7 91.8 91.88 83.36 84.58 87.42 91.44 89.7 88.48 90.82 91 91.06 72.6 76.56 79.12</td><td>64.36 62.02 58.68 69.3 68.98 68.64 53.72 57.28 60.68 65.52 61.98 59.1 67.38 67.58 67.06 34.8 41.82 45.6</td></tr></table>

Cross-Validation for AMSGRAD on WRN architecture with data augmentation (best validation accuracy obtained during training).performance: sometimes a better-behaved convergence would be obtained on the training set with a lower learning rate. However this lower learning rate is not selected because it does not provide the best validation performance.

Table content: <table/>

C EXPERIMENTAL DETAILS ON THE SNLI DATA SET Cross-Validation for ADAGRAD on BLSTM architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>C.1 CROSS-VALIDATION</td><td/><td/></tr><tr><td>η</td><td colspan="2">Accuracy CE (%) Accuracy SVM (%)</td></tr><tr><td>0.001</td><td>83.43</td><td>84.16</td></tr><tr><td>0.01 0.1</td><td>83.77 62.09</td><td>84.62 34.5</td></tr><tr><td>η</td><td colspan="2">Accuracy CE (%) Accuracy SVM (%)</td></tr><tr><td>1e-05</td><td>83.18</td><td>83.02</td></tr><tr><td>0.0001 0.001 0.01</td><td>84.56 84.42 33.82</td><td>84.69 83.31 33.82</td></tr></table>

Cross-Validation for ADAM on BLSTM architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>η</td><td colspan="2">Accuracy CE (%) Accuracy SVM (%)</td></tr><tr><td>1e-05</td><td>82.81</td><td>82.95</td></tr><tr><td>0.0001 0.001 0.01</td><td>84.69 84.66 36.78</td><td>84.83 83.59 38.25</td></tr></table>

Cross-Validation for AMSGRAD on BLSTM architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>η</td><td colspan="2">Accuracy CE (%) Accuracy SVM (%)</td></tr><tr><td>0.001 0.01 0.1</td><td>75.51 83.09 83.93</td><td>74.87 83.02 84.24</td></tr><tr><td>1.0 10</td><td>84.28 33.82</td><td>84.73 33.31</td></tr></table>

Cross-Validation for BPGRAD on BLSTM architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>η</td><td>Accuracy (%)</td></tr><tr><td>0.1</td><td>84.87</td></tr><tr><td>1.0 10</td><td>85.21 84.76</td></tr></table>

Cross-Validation for DFW on BLSTM architecture (best validation accuracy obtained during training).

Table content: <table><tr><td>η</td><td colspan="2">Accuracy CE (%) Accuracy SVM (%)</td></tr><tr><td>0.01 0.1 1.0 10</td><td>84.22 84.63 85.06 34.59</td><td>84.59 85.15 84.7 34.51</td></tr></table>

Cross-Validation for SGD on BLSTM architecture (best validation accuracy obtained during training).

Table content: <table/>

Peer review (iclr2019):
 This paper introduced a proximal approach to optimize neural networks by linearizing the network output instead of the loss function. They demonstrate their algorithm on multi-class hinge loss, where they can show that optimal step size can be computed in close form without significant additional cost. Their experimental results showed competitive performance to SGD/Adam on the same network architectures. 1. Figure 1 is crucial to the algorithm design as it aims to prove that Loss-Preserving Linearization (LPL) preserves information on loss function. While the authors provided numerical plots to compare it with the SGD linearization, I personally prefer to see some analytically comparsion between SGD linearization and LPL even on the simplest case. An appendix with more numerical comparisons on other loss functions might also be insightful. 2. It seems LPL is mainly compared to SGD for convergence (e.g. Fig 2). In Table 2 I saw some optimizers end up with much lower test accuracy. Can the authors show the convergence plots of these methods (similar to Figure 2)?