Title: Trusting SVM for Piecewise Linear CNNs

Abstract: We present a novel layerwise optimization algorithm for the learning objective of Piecewise-Linear Convolutional Neural Networks (PL-CNNs), a large class of convolutional neural networks. Specifically, PL-CNNs employ piecewise linear non-linearities such as the commonly used ReLU and max-pool, and an SVM classifier as the final layer. The key observation of our approach is that the problem corresponding to the parameter estimation of a layer can be formulated as a difference-of-convex (DC) program, which happens to be a latent structured SVM. We optimize the DC program using the concave-convex procedure, which requires us to iteratively solve a structured SVM problem. This allows to design an optimization algorithm with an optimal learning rate that does not require any tuning. Using the MNIST, CIFAR and ImageNet data sets, we show that our approach always improves over the state of the art variants of backpropagation and scales to large data and large network settings.

1. Introduction:

The backpropagation algorithm is commonly employed to estimate the parameters of a convolutional neural network (CNN) using a supervised training data set (Rumelhart et al., 1986) . Part of the appeal of backpropagation comes from the fact that it is applicable to a wide variety of networks, namely those that have (sub-)differentiable non-linearities and employ a (sub-)differentiable learning objective. However, the generality of backpropagation comes at the cost of a high sensitivity to its hyperparameters such as the learning rate and momentum. Standard line-search algorithms cannot be used on the primal objective function in this setting, as (i) there may not exist a step-size guaranteeing a monotonic decrease because of the use of sub-gradients, and (ii) even in the smooth case, each function evaluation requires a forward pass over the entire data set without any update, making the approach computationally unfeasible. Choosing the learning rate thus remains an open issue, with the state-of-the-art algorithms suggesting adaptive learning rates (Duchi et al., 2011; Zeiler, 2012; Kingma & Ba, 2015) . In addition, techniques such as batch normalization (Ioffe & Szegedy, 2015) and dropout (Srivastava et al., 2014) have been introduced to respectively reduce the sensitivity to the learning rate and to prevent from overfitting.

With this work, we open a different line of inquiry, namely, is it possible to design more robust optimization algorithms for special but useful classes of CNNs? To this end, we focus on the networks that are commonly used in computer vision. Specifically, we consider CNNs with convolutional and dense layers that apply a set of piecewise linear (PL) non-linear operations to obtain a discriminative representation of an input image. While this assumption may sound restrictive at first, we show that commonly used non-linear operations such as ReLU and max-pool fall under the category of PL functions. The representation obtained in this way is used to classify the image via a multi-class SVM, which forms the final layer of the network. We refer to this class of networks as PL-CNN.

We design a novel, principled algorithm to optimize the learning objective of a PL-CNN. Our algorithm is a layerwise method, that is, it iteratively updates the parameters of one layer while keeping the other layers fixed. For this work, we use a simple schedule over the layers, namely, repeated passes from the output layer to the input one. However, it may be possible to further improve the accuracy and efficiency of our algorithm by designing more sophisticated scheduling strategies. The key observation of our approach is that the parameter estimation of one layer of PL-CNN can be formulated as a difference-of-convex (DC) program that can be viewed as a latent structured SVM problem (Yu & Joachims, 2009) . This allows us to solve the DC program using the concave-convex procedure (CCCP) (Yuille & Rangarajan, 2002) . Each iteration of CCCP requires us to solve a convex structured SVM problem. To this end, we use the powerful block-coordinate Frank-Wolfe (BCFW) algorithm (Lacoste-Julien et al., 2013) , which solves the dual of the convex program iteratively by computing the conditional gradients corresponding to a subset of training samples. In order to further improve BCFW for PL-CNNs, we extend it in three important ways. First, we introduce a trust-region term that allows us to initialize the BCFW algorithm using the current estimate of the layer parameters. Second, we reduce the memory requirement of BCFW by an order of magnitude, via an efficient representation of the feature vectors corresponding to the dense layers. Third, we show that, empirically, the number of constraints of the structural SVM problem can be reduced substantially without any loss in accuracy, which allows us to significantly reduce its time complexity.

Compared to backpropagation (Rumelhart et al., 1986) or its variants (Duchi et al., 2011; Zeiler, 2012; Kingma & Ba, 2015) , our algorithm offers three advantages. First, the CCCP algorithm provides a monotonic decrease in the learning objective at each layer. Since layerwise optimization itself can be viewed as a block-coordinate method, our algorithm guarantees a monotonic decrease of the overall objective function after each layer's parameters have been updated. Second, since the dual of the SVM problem is a smooth convex quadratic program, each step of the BCFW algorithm (in the inner iteration of the CCCP) provides a monotonic increase in its dual objective. Third, since the only step-size required in our approach comes while solving the SVM dual, we can use the optimal step-size that is computed analytically during each iteration of BCFW (Lacoste-Julien et al., 2013) . In other words, our algorithm has no learning rate, initial or not, that requires tuning.

Using standard network architectures and publicly available data sets, we show that our algorithm provides a boost over the state of the art variants of backpropagation for learning PL-CNNs and we demonstrate scalability of the method.

2. Related Work:

While some of the early successful approaches for the optimization of deep neural networks relied on greedy layer-wise training (Hinton et al., 2006; Bengio et al., 2007) , most currently used methods are variants of backpropagation (Rumelhart et al., 1986 ) with adaptive learning rates, as discussed in the introduction.

At every iteration, backpropagation performs a forward pass and a backward pass on the network, and updates the parameters of each layer by stochastic or mini-batch gradient descent. This makes the choice of the learning rate critical for efficient optimization. Duchi et al. (2011) have proposed the Adagrad convex solver, which adapts the learning rate for every direction and takes into account past updates. Adagrad changes the learning rate to favor steps in gradient directions that have not been observed frequently in past updates. When applied to the non-convex CNN optimization problem, Adagrad may converge prematurely due to a rapid decrease in the learning rate (Goodfellow et al., 2016) . In order to prevent this behavior, the Adadelta algorithm (Zeiler, 2012) makes the decay of the learning rate slower. It is worth noting that this fix is empirical, and to the best of our knowledge, provides no theoretical guarantees. Kingma & Ba (2015) propose a different scheme for the learning rate, called Adam, which uses an online estimation of the first and second moments of the gradients to provide centered and normalized updates. However all these methods still require the tuning of the initial learning rate to perform well.

Second-order and natural gradient optimization methods have also been a subject of attention. The focus in this line of work has been to come up with appropriate approximations to make the updates cheaper. Martens & Sutskever (2012) suggested a Hessian-free second order optimization using finite differences to approximate the Hessian and conjugate gradient to compute the update. Martens & Grosse (2015) derive an approximation of the Fisher matrix inverse, which provides a more efficient method for natural gradient descent. Ollivier (2013) explore a set of Riemannian methods based on natural gradient descent and quasi-Newton methods to guarantee reparametrization invariance of the problem. Desjardins et al. (2015) demonstrate a scaled up natural gradient descent method by training on the ImageNet data set (Russakovsky et al., 2015) . Though providing more informative updates and solid theoretical support than SGD-based approaches, these methods do not take into account the structure of the problem offered by the commonly used non-linear operations.

Our work is also related to some of the recent developments in optimization for deep learning. For example, Taylor et al. (2016) use ADMM for massive distribution of computation in a layer-wise fashion, and in particular their method will yield closed-form updates for any PL-CNN. Lee et al. (2015) propose to use targets instead of gradients to propagate information through the network, which could help to extend our algorithm. Zhang et al. (2016) derive a convex relaxation for the learning objective for a restricted class of CNNs, which also relies on solving an approximate convex problem. In (Amos et al., 2016) , the authors identify convex problems for the inference task, when the neural network is a convex function of some of its inputs.

With a more theoretical approach, Goel et al. (2016) propose an algorithm to learn shallow ReLU nets with guarantees of time convergence and generalization error. Heinemann et al. (2016) show that a subclass of neural networks can be modeled as an improper kernel, which then reduces the learning problem to a simple SVM with the constructed kernel.

More generally, we believe that our hitherto unknown observation regarding the relationship between PL-CNNs and latent SVMs can (i) allow the progress made in one field to be transferred to the other and (ii) help design a new generation of principled algorithms for deep learning optimization.

3. Piecewise Linear Convolutional Neural Networks:

A piecewise linear convolutional neural network (PL-CNN) consists of a series of convolutional layers, followed by a series of dense layers, which provides a concise representation of an input image. Each layer of the network performs two operations: a linear transformation (that is, a convolution or a matrix multiplication), followed by a piecewise linear non-linear operation such as ReLU or max-pool. The resulting representation of the image is used for classification via an SVM. In the remainder of this section, we provide a formal description of PL-CNN.

Piecewise Linear Functions. A piecewise linear (PL) function f (u) is a function of the following form (Melzer, 1986) :

EQUATION

where

[m] = {1, • • • , m}, and [n] = {1, • • • , n}.

Each of the two maxima above is a convex function, therefore such a function f is not generally convex, but it is rather a difference of two convex functions. Importantly, many commonly used non-linear operations such as ReLU or max-pool are PL functions of their input. For example, ReLU corresponds to the function R(v) = max{v, 0} where v is a scalar. Similarly, max-pool for a D-dimensional vector u corresponds to M (u) = max i∈[D] {e i u}, where e i is a vector whose i-th element is 1 and all other elements are 0. Given a value of u, we say that (i * , j * ) is the activation of the PL function at u if i * = argmax i∈[m] {a i u} and j * = argmax j∈[n] {b j u}.

PL-CNN Parameters. We denote the parameters of an L layer PL-CNN by W = {W l ; l ∈ [L]}. In other words, the parameters of the l-th layer is defined as W l . The CNN defines a composite function, that is, the output z l-1 of layer l -1 is the input to the layer l.

Given the input z l-1 to layer l, the output is computed as z l = σ l (W l • z l-1 ), where "•" is either a convolution or a matrix multiplication, and σ l is a PL non-linear function, such as ReLU or max-pool. The input to the first layer is an image x, that is, z 0 = x. We denote the input to the final layer by z L = Φ(x; W) ∈ R D . In other words, given an image x, the convolutional and dense layers of a PL-CNN provide a D-dimensional representation of x to the final classification layer. The final layer of a PL-CNN is a C class SVM W svm , which specifies one parameter W svm y ∈ R D for each class y ∈ Y.

Prediction. Given an image x, a PL-CNN predicts its class using the following rule:

EQUATION

In other words, the dot product of the D-dimensional representation of x with the SVM parameter for a class y provides the score for the class. The desired prediction is obtained by maximizing the score over all possible classes.

Learning Objective. Given a training data set D = {(x i , y i ), i ∈ [N ]}, where x i is the input image and y i is its ground-truth class, we wish to estimate the parameters W ∪ W svm of the PL-CNN. To this end, we minimize a regularized upper bound on the empirical risk.

The risk of a prediction y * i given the ground-truth y i is measured with a user-specified loss function ∆(y * i , y i ). For example, the standard 0 -1 loss has a value of 0 for a correct prediction and 1 for an incorrect prediction. Formally, the parameters of a PL-CNN are estimated using the following learning objective:

min W,W svm λ 2 l∈[L]∪{svm} W l 2 F + 1 N N i=1 max ȳi∈Y ∆(ȳ i , y i ) + W svm ȳi -W svm yi T Φ(x i ; W) . (3)

The hyperparameter λ denotes the relative weight of the regularization compared to the upper bound of the empirical risk. Note that, due to the presence of piecewise linear non-linearities, the representation Φ(•; W) (and hence, the above objective) is highly non-convex in the PL-CNN parameters.

4. Parameter Estimation for PL-CNN:

In order to enable layerwise optimization of PL-CNNs, we show that parameter estimation of a layer can be formulated as a difference-of-convex (DC) program (subsection 4.1). This allows us to use the concave-convex procedure, which solves a series of convex optimization problems (subsection 4.2). We show that each convex problem closely resembles a structured SVM objective, which can be addressed by the powerful block-coordinate Frank-Wolfe (BCFW) algorithm. We extend BCFW to improve its initialization, time complexity and memory requirements, thereby enabling its use in learning PL-CNNs (subsection 4.3). For the sake of clarity, we only provide sketches of the proofs for those propositions that are necessary for understanding the paper. The detailed proofs of the remaining propositions are provided in the Appendix.

4.1. Layerwise Optimization as a DC Program:

Given the values of the parameters for the convolutional and the dense layers (that is, W), the learning objective (3) is the standard SVM problem in parameters W svm . In other words, it is a convex optimization problem with several efficient solvers (Tsochantaridis et al., 2004; Joachims et al., 2009; Shalev-Shwartz et al., 2009) , including the BCFW algorithm (Lacoste-Julien et al., 2013) . Hence, the optimization of the final layer is a computationally easy problem. In contrast, the optimization of the parameters of a convolutional or a dense layer l does not result in a convex program. In general, this problem can be arbitrarily hard to solve. However, in the case of PL-CNN, we show that the problem can be formulated as a specific type of DC program, which enables efficient optimization via the iterative use of BCFW. The key property that enables our approach is the following proposition that shows that the composition of PL functions is also a PL function. Proposition 1. Consider PL functions g : R m → R and g i :

R n → R, for all i ∈ [m]. Define a function f : R n → R as f (u) = g([g 1 (u), g 2 (u), • • • , g m (u)] ). Then f is also a PL function (proof in Appendix A).

Using the above proposition, we can reformulate the problem of optimizing the parameters of one layer of the network as a DC program. Specifically, the following proposition shows that the problem can be formulated as a latent structured SVM objective (Yu & Joachims, 2009) . Proposition 2. The learning objective of a PL-CNN with respect to the parameters of the l-th layer can be specified as follows:

EQUATION

for an appropriate choice of the latent space H and joint feature vectors Ψ(x, y, h) of the input x, the output y and the latent variables h. In other words, parameter estimation for the l-th layer corresponds to minimizing the sum of its Frobenius norm plus a PL function for each training sample.

Sketch of the Proof. For a given image x with the ground-truth class y, consider the input to the layer l, which we denote by z l-1 . Since all the layers except the l-th one are fixed, the input z l-1 is a constant vector, which only depends on the image x (that is, its value does not depend on the variables W l ). In other words, we can write z l-1 = ϕ(x).

Given the input z l-1 , all the elements of the output of the l-th layer, denoted by z l , are a PL function of W l since the layer performs a linear transformation of z l-1 according to the parameters W l , followed by an application of PL operations such as ReLU or max-pool.

The vector z l is then fed to the (l + 1)-th layer. The output z l+1 of the (l + 1)-th layer is a vector whose elements are PL functions of z l . Therefore, by proposition (1), the elements of z l+1 are a PL function of W l . By applying the same argument until we reach the layer L, we can conclude that the representation Φ(x; W) is a PL function of W l .

Next, consider the upper bound of the empirical risk, which is specified as follows:

EQUATION

Once again, since W svm is fixed, the above upper bound can be interpreted as a PL function of Φ(x; W), and thus, by proposition (1), the upper bound is a PL function of W l . It only remains to observe that the learning objective (3) also contains the Frobenius norm of W l . Thus, it follows that the estimation of the parameters of layer l can be reformulated as minimizing the sum of its Frobenius norm and the PL upper bound of the empirical risk over all training samples, as shown in problem (4). Note that we have ignored the constants corresponding to the Frobenius norm of the parameters of all the fixed layers. This constitutes an existential proof of Proposition 2. In the next paragraph, we give an intuition about the feature vectors Ψ(x i , ȳi , h i ) and the latent space H.

Feature Vectors & Latent Space. The exact form of the joint feature vectors depends on the explicit DC decomposition of the objective function. In Appendix B, we detail the practical computations and give an example: we construct two interleaved neural networks whose outputs define the convex and concave parts of the DC objective function. Given the explicit DC objective function, the feature vectors are given by a subgradient and can therefore be obtained by automatic differentiation.

We now give an intuition of what the latent space H represents. Consider an input image x and a corresponding latent variable h ∈ H. The latent variable can be viewed as a set of variables

h k , k ∈ {l + 1, • • • , L}.

In other words, each subset h k of the latent variable corresponds to one of the layers of the network that follow the layer l. Intuitively, h k represents the choice of activation at layer k when going through the PL activation: for each neuron j of layer k, h k j takes value i if and only if the i-th piece of the piecewise linear activation is selected. For instance, i is the index of the selected input in the case of a max-pooling unit.

Note that the latent space only depends on the layers that follow the current layer being optimized. This is due to the fact that the input z l-1 to the l-th layer is a constant vector that does not depend on the value of W l . However, the activations of all subsequent layers following the l-th one depend on the value of the parameters W l . As a consequence, the greater the number of following layers, the greater the size of the latent space, and this growth happens to be exponential. However, as will be seen shortly, it is still possible to efficiently optimize problem (4) for all the layers of the network despite this exponential increase.

4.2. Concave-Convex Procedure:

The optimization problem (4) is a DC program in the parameters W l . This follows from the fact that the upper bound of the empirical risk is a PL function, and can therefore be expressed as the difference of two convex PL functions (Melzer, 1986) . Furthermore, the Frobenius norm of W l is also a convex function of W l . This observation allows us to obtain an approximate solution of problem (4) using the iterative concave-convex procedure (CCCP) (Yuille & Rangarajan, 2002) .

Algorithm 1 describes the main steps of CCCP. In step 3, we impute the best value of the latent variable corresponding to the ground-truth class y i for each training sample. This imputation corresponds to the linearization step of the CCCP. The selected latent variable corresponds to a choice of activations at each non-linear layer of the network, and therefore defines a path of activations to the ground truth. Next, in step 4, we update the parameters by solving a convex optimization problem. This convex problem amounts to finding the path of activations which minimizes the maximum margin violations given the path to the ground truth defined in step 3.

The CCCP algorithm has the desirable property of providing a monotonic decrease in the objective function at each iteration. In other words, the objective function value of problem (4) at W l t is greater than or equal to its value at W l t+1 . Since layerwise optimization itself can be viewed as a block-coordinate algorithm for minimizing the learning objective (3), our overall algorithm provides guarantees of monotonic decrease until convergence. This is one of the main advantages of our approach compared to backpropagation and its variants, which fail to provide similar guarantees on the value of the objective function from one iteration to the next.

Algorithm 1 CCCP for parameter estimation of the l-th layer of the PL-CNN.

Require: Data set D = {(x i , y i ), i ∈ [N ]}, fixed parameters {W ∪ W svm }\W l , initial estimate W l 0 . 1: t = 0 2: repeat 3:

For each sample (x i , y i ), find the best latent variable value by solving the following problem:

EQUATION

)

4:

Update the parameters by solving the following convex optimization problem:

EQUATION

)

5:

t = t+1 6: until Objective function of problem (4) cannot be improved beyond a specified tolerance.

In order to solve the convex program (7), which corresponds to a structured SVM problem, we make use of the powerful BCFW algorithm (Lacoste-Julien et al., 2013) that solves its dual via conditional gradients. This has two main advantages: (i) as the dual is a smooth quadratic program, each iteration of BCFW provides a monotonic increase in its objective; and (ii) the optimal step-size at each iteration can be computed analytically. This is once again in stark contrast to backpropagation, where the estimation of the step-size is still an active area of research (Duchi et al., 2011; Zeiler, 2012; Kingma & Ba, 2015) . As shown by Lacoste-Julien et al. (2013) , given the current estimate of the parameters W l , the conditional gradient of the dual of program ( 7) with respect to a training sample (x i , y i ) can be obtained by solving the following problem:

EQUATION

)

We refer the interested reader to (Lacoste-Julien et al., 2013) for further details.

The overall efficiency of the CCCP algorithm relies on our ability to solve problems ( 6) and ( 8). At first glance, these problems may appear to be computationally intractable as the latent space H can be very large, especially for layers close to the input (of the order of millions of dimensions for a typical network). However, the following proposition shows that both the problems can be solved efficiently using the forward and backward passes that are employed in backpropagation.

Proposition 3. Given the current estimate W l of the parameters for the l-th layer, as well as the parameter values of all the other fixed layers, problems ( 6) and ( 8) can be solved using a forward pass on the network. Furthermore, the joint feature vectors Ψ(x i , ŷi , ĥi ) and Ψ(x i , y i , h * i ) can be computed using a backward pass on the network.

Sketch of the Proof. Recall that the latent space consists of the putative activations for each PL operation in the layers following the current one. Thus, intuitively, the maximization over the latent variables corresponds to finding the exact activations of all such PL operations.

In other words, we need to identify the indices of the linear pieces that are used to compute the value of the PL function in the current state of the network. For a ReLU operation, this corresponds to estimating max{0, v}, where the input to the ReLU is a scalar v. Similarly, for a max-pool operation, this corresponds to estimating max i {e i u}, where u is the input vector to the max-pool. This is precisely the computation that the forward pass of backpropagation performs. Given the activations, the joint feature vector is the subgradient of the sample with respect to the current layer. Once again, this is precisely what is computed during the backward pass of the backpropagation algorithm.

An example is constructed in Appendix B to illustrate how to compute the feature vectors in practice.

4.3. Improving the BCFW Algorithm:

As the BCFW algorithm was originally designed to solve a structured SVM problem, it requires further extensions to be suitable for training a PL-CNN. In what follows, we present three such extensions that improve the initialization, memory requirements and time complexity of the BCFW algorithm respectively.

Trust-Region for Initialization. The original BCFW algorithm starts with an initial parameter W l = 0 (that is, all the parameters are set to 0). The reason for this initialization is that it is possible to compute the dual variables that correspond to the 0 primal variable. However, since our algorithm visits each layer of the network several times, it would be desirable to initialize its parameters using its current value W t l . To this end, we introduce a trust-region in the constraints of problem (7), or equivalently, an 2 norm based proximal term in its objective function (Parikh & Boyd, 2014) . The following proposition shows that this has the desired effect of initializing the BCFW algorithm close to the current parameter values.

Proposition 4. By adding a proximal term µ 2 W l -W l t 2

F to the objective function in (7), we can compute a feasible dual solution whose corresponding primal solution is equal to µ λ+µ W l t . Furthermore, the addition of the proximal term still allows us to efficiently compute the conditional gradient using a forward-backward pass (proof in Appendix D).

Published as a conference paper at ICLR 2017:

In practice, we always choose a value of µ = 10λ: this yields an initialization of 0.9W l t which does not significantly change the value of the objective function.

Efficient Representation of Joint Feature Vectors. The BCFW algorithm requires us to store a linear combination of the feature vectors for each mini-batch. While this requirement is not too stringent for convolutional and multi-class SVM layers, where the dimensionality of the feature vectors is small, it becomes prohibitively expensive for dense layers. The following proposition prevents a blow-up in the memory requirements of BCFW.

Proposition 5. When optimizing dense layer l, if W l ∈ R p×q , we can store a representation of the joint feature vectors Ψ(x, y, h) with vectors of size p in problems ( 6) and ( 7). This is in contrast to the naïve approach that requires them to be of size p × q.

Sketch of the Proof. By Proposition (3), the feature vectors are subgradients of the hinge loss function, which we loosely denote by η for this proof. Then by the chain rule:

∂η ∂W l = ∂η ∂z l ∂z l ∂W l = ∂η ∂z l • z l-1 T .

Noting that z l-1 ∈ R q is a forward pass up until layer l (independent of W l ), we can store only ∂η ∂z l ∈ R p and still reconstruct the full feature vector ∂η ∂W l by a forward pass and an outer product.

Reducing the Number of Constraints. In order to reduce the amount of time required for the BCFW algorithm to converge, we use the structure of H to simplify problem (7) to a much simpler problem. Specifically, since H represents the activations of the network for a given sample, it has a natural decomposition over the layers: H = H 1 × ... × H L . We use this structure in the following observation.

Observation 1. Problem ( 7) can be approximately solved by optimizing the dual problem on increasingly large search spaces. In other words, we start with constraints of Y, followed by Y × H L , then Y × H L × H L-1 and so on. The algorithm converges when the primal-dual gap is below tolerance.

The latent variables which are not optimized over are set to be the same as the ones selected for the ground truth. Experimentally, we observe that for convolutional layers (architectures in section 5), restricting the search space to Y yields a dual gap low enough to consider the problem has converged. This means that in practice for these layers, problem (7) can be solved by searching directions over the search space Y instead of the much larger Y × H. The intuition is that the norm of the difference-of-convex decomposition grows with the number of activations selected differently in the convex and concave parts (see Appendix A for the decomposition of piecewise linear functions). This compels the path of activations to be the same in the convex and the concave part to avoid large margin violations, especially for convolutional layers which are followed by numerous non-linearities at the max-pooling layers.

5. Experiments:

Our experiments are designed to assess the ability of LW-SVM (Layer-Wise SVM, our method) and the SGD baselines to optimize problem (3). To compare LW-SVM with the state-of-the-art variants of backpropagation, we look at the training and testing accuracies as well as the training objective value. Unlike dropout, which effectively learns an ensemble model, we learn a single model using each baseline optimization algorithm. All experiments are conducted on a GPU (Nvidia Titan X) and use Theano (Bergstra et al., 2010; Bastien et al., 2012) . We compare LW-SVM with Adagrad, Adadelta and Adam. For all data sets, we start at a good solution provided by these solvers and fine-tune it with LW-SVM. We then check whether a longer run of the SGD solver reaches the same level of performance.

The practical use of the LW-SVM algorithm needs choices at the three following levels: how to select the layer to optimize (i), when to stop the CCCP on each layer (ii) and when to stop the convex optimization at each inner iteration of the CCCP (iii). These choices are detailed in the next paragraph.

The layer-wise schedule of LW-SVM is as follows: as long as the validation accuracy increases, we perform passes from the end of the network (SVM) to the first layer (i). At each pass, each layer is optimized with one outer iteration of the CCCP (ii). The inner iterations are stopped when the dual objective function does not increase by more than 1% over an epoch (iii) . We point out that the dual objective function is cheap to compute since we are maintaining its value at all time. By contrast, to compute the exact primal objective function requires a forward pass over the data set without any update.

5.1. MNIST Data Set:



Data set & Architecture:

The training data set consists in 60,000 gray scale images of size 28 × 28 with 10 classes, which we split into 50,000 samples for training and 10,000 for validating. The images are normalized, and we do not use any data augmentation. The architecture used for this experiment is shown in Figure 1 . Method The number of epochs is set to 200, 100 and 100 for Adagrad, Adadelta and Adam -Adagrad is given more epochs as we observed it took a longer time to converge. We then use LW-SVM and compare the results on training objective, training accuracy and testing accuracy. We also let the solvers run to up to 500 epochs to verify that we have not stopped the optimization prematurely. The regularization hyperparameter λ and the initial learning rate are chosen by cross-validation. λ is set to 0.001 for all solvers, and the initial learning rates can be found in Appendix C. For LW-SVM, λ is set to the same value as the baseline, and the proximal term µ to µ = 10λ = 0.01. Results on MNIST of Adagrad, Adadelta and Adam followed by LW-SVM. We verify that switching to LW-SVM leads to better solutions than running SGD longer (shaded continued plots).

5.2. CIFAR Data Sets:



Data sets & Architectures:

The CIFAR-10/100 data sets are comprised of 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 in both cases. The images are centered and normalized, and we do not use any data augmentation. To obtain a strong enough baseline, we employ (i) a pre-training with a softmax and cross-entropy loss and (ii) Batch-Normalization (BN) layers before each non-linearity.

We have experimentally found out that pre-training with a softmax layer followed by a cross-entropy loss led to better behavior and results than using an SVM loss alone. The baselines are trained with batch normalization. Once they have converged, the estimated mean and standard deviation are fixed like they would be at test time. Then batch normalization becomes a linear transformation, which can be handled by the LW-SVM algorithm. This allows us to compare LW-SVM with a baseline benefiting from batch normalization. Specifically, we use the architecture shown in Figure 3 : Method Again, the initial learning rates and regularization weight λ are obtained by cross-validation, and a value of 0.001 is obtained for λ for all solvers on both datasets. As before, µ is set to 10λ. The initial learning rates are reported in Appendix C. The layer schedule and convergence criteria are as described at the beginning of the section. For each SGD optimizer, we train the network for 10 epochs with a cross-entropy loss (preceded by a softmax layer). Then it is trained with an SVM loss (without softmax) for respectively 1000, 100 and 100 epochs for Adagrad, Adadelta and Adam. This amount is doubled to verify that the baselines are not harmed by a premature stopping. Results are presented in Tables 2 and 3 . CIFAR-10. The automatic step-size allows for a precise fine-tuning to optimize the training objective, while the regularization of the proximal term helps for better generalization.

5.3. ImageNet Data Set:

We show results on the classification task of the ImageNet data set (Russakovsky et al., 2015) . The ImageNet data set contains 1.2 million images for training and 50,000 images for validation, each of them mapped to one of the 1,000 classes. For this experiment we use a VGG-16 network (configuration D in (Simonyan & Zisserman, 2015) ). We start with a pre-trained model as publicly available online, and we tune each of the dense layers as well as the final SVM layer with the LW-SVM algorithm. This experiment is designed to test the scalability of LW-SVM to large data sets and large networks, rather than comparing with the optimization baselines as before -indeed for any baseline, obtaining proper convergence as in previous experiments would take a very long time. We set the hyperparameters λ to 0.001 and µ to 10λ as previously. We budget five epochs per layer, which in total takes two days of training on a single GPU (Nvidia Titan X). At training time we used centered crops of size 224 × 224. The evaluation method is the same as the single test scale method described in (Simonyan & Zisserman, 2015) . We report the results on the validation set in Table 4 , for the Pre-Trained model (PT) and the same model further optimized by LW-SVM (PT+LW-SVM):

Table 4 : Results on the 1,000-way classification challenge of ImageNet on the validation set, for the Pre-Trained model (PT) and the same model further optimized by LW-SVM (PT+LW-SVM).

Network:

Top-1 Accuracy Top-5 Accuracy VGG-16 (PT) 73.30% 91.33% VGG-16 (PT + LW-SVM) 73.81% 91.61%

Since the objective function penalizes the top-1 error, it is logical to observe that the improvement is most important on the top-1 accuracy. Importantly, having an efficient representation of feature vectors proves to be essential for such large networks: for instance, in the optimization of the first fully connected layer with a batch-size of 100, the use of our representation lowers the memory requirements of the BCFW algorithm from 7,600GB to 20GB, which can then fit in the memory of a powerful computer.

6. Discussion:

We presented a novel layerwise optimization algorithm for a large and useful class of convolutional neural networks, which we term PL-CNNs. Our key observation is that the optimization of the parameters of one layer of a PL-CNN is equivalent to solving a latent structured SVM problem. As the problem is a DC program, it naturally lends itself to the iterative CCCP approach, which optimizes a convex structured SVM objective at each iteration. This allows us to leverage the advancements made in structured SVM optimization over the past decade to design a computationally feasible approach for learning PL-CNNs. Specifically, we use the BCFW algorithm and extend it to improve its initialization, memory requirements and time complexity. In particular, this allows our method to not require the tuning of any learning rate. Using the publicly available MNIST, CIFAR-10 and CIFAR-100 data sets, we show that our approach provides a boost for learning PL-CNNs over the state of the art backpropagation algorithms. Furthermore, we demonstrate scalability of the method with results on the ImageNet data set with a large network.

When the mean and standard deviation estimations of batch normalization are not fixed (unlike in our experiments with LW-SVM), batch normalization is not a piecewise linear transformation, and therefore cannot be used in conjunction with the BCFW algorithm for SVMs. However, it is difference-of-convex as it is a C 2 function (Horst & Thoai, 1999) .

Incorporating a normalization scheme into our framework will be the object of future work. With our current methodology, LW-SVM algorithm can already be used on most standard architectures like VGG, Inception and ResNet-type architectures.

It is worth noting that other approaches for solving structured SVM problems, such as cutting-plane algorithms (Tsochantaridis et al., 2004; Joachims et al., 2009) and stochastic subgradient descent (Shalev-Shwartz et al., 2009) , also rely on the efficiency of estimating the conditional gradient of the dual. Hence, all these methods are equally applicable to our setting. Indeed, the main strength of our approach is the establishment of a hitherto unknown connection between CNNs and latent structured SVMs. We believe that our observation will allow researchers to transfer the substantial existing knowledge of DC programs in general, and latent SVMs specifically, to produce the next generation of principled optimization algorithms for deep learning. In fact, there are already several such improvements that can be readily applied in our setting, which were not explored only due to a lack of time. This includes multi-plane variants of BCFW (Shah et al., 2015; Osokin et al., 2016) , as well as generalizations of Frank-Wolfe such as partial linearization (Mohapatra et al., 2016) .

A Piecewise Linear Functions:

Proof of Proposition (1) By the definition from (Melzer, 1986) , we can write each function as the difference of two point-wise maxima of linear functions:

g(v) = max j∈[m+] {a i v} -max k∈[m-] {b j v}

And ∀i ∈ [n], g i (u) = g + i (u) -g - i (u) Where all the g + i , g - i are linear point-wise maxima of linear functions. Then:

f (u) = g([g 1 (u), • • • , g n (u)] ) = max j∈[m+] {a j [g 1 (u), • • • , g n (u)] } -max k∈[m-] {b k [g 1 (u), • • • , g n (u)] } = max j∈[m+] n i=1 a j,i g i (u) -max k∈[m-] n i=1 b k,i g i (u) = max j∈[m+] n i=1 a j,i g + i (u) - n i=1 a j,i g - i (u) -max k∈[m-] n i=1 b k,i g + i (u) - n i=1 b k,i g - i (u) = max j∈[m+]    n i=1 a j,i g + i (u) + j ∈[m+]\{j} n i=1 a j,i g - i (u)    - j ∈[m+] n i=1 a j,i g - i (u) -max k∈[m-]    n i=1 b k,i g + i (u) + k ∈[m-]\{k} n i=1 b k,i g - i (u)    + k ∈[m-] n i=1 b k,i g - i (u) = max j∈[m+]    n i=1 a j,i g + i (u) + j ∈[m+]\{j} n i=1 a j,i g - i (u)    + k ∈[m-] n i=1 b k,i g - i (u) -   max k∈[m-]    n i=1 b k,i g + i (u) + k ∈[m-]\{k} n i=1 b k,i g - i (u)    + j ∈[m+] n i=1 a j,i g - i (u)   = max j∈[m+]    n i=1 a j,i g + i (u) + j ∈[m+]\{j} n i=1 a j,i g - i (u) + k ∈[m-] n i=1 b k,i g - i (u)    -max k∈[m-]    n i=1 b k,i g + i (u) + k ∈[m-]\{k} n i=1 b k,i g - i (u) + j ∈[m+] n i=1 a j,i g - i (u)   

In each line of the last equality, we recognize a pointwise maximum of a linear combination of pointwise maxima of linear functions. This constitutes a pointwise maximum of linear functions.

This derivation also extends equation ( 10) to the multi-dimensional case by showing an explicit DC decomposition of the output.

B Computing the Feature Vectors:

We describe here how to compute the feature vectors in practice. To this end, we show how to construct two (intertwined) neural networks that decompose the objective function into a convex and a concave part. We call these Difference of Convex (DC) networks. Once the DC networks are defined, a standard forward and backward pass in the two networks yields the feature vectors for the convex and concave contribution to the objective function. First, we derive how to perform a DC decomposition in linear and non-linear layers, and then we construct an example of DC networks.

DC Decomposition in a Linear Layer Let W be the weights of a fixed linear layer. We introduce W + = 1 2 (|W | + W ) and W -= 1 2 (|W | -W ). We can note that W + and W - have exclusively non-negative weights, and that W = W + -W -. Say we have an input u with the DC decomposition (u cvx , u ccv ), that is: u = u cvx -u ccv , where both u cvx and u ccv are convex. Then we can decompose the output of the layer as:

W • u = (W + • u cvx + W -• u ccv ) convex -(W -• u cvx + W + • u ccv ) convex (9)

DC Decomposition in a Piecewise Linear Activation Layer For simplicity purposes, we consider that the non-linear layer is a point-wise maximum across [K] scalar inputs, that is, for an input (u k ) k∈[K] ∈ R K , the output is max k∈[K] u k (the general multi-dimensional case can be found in Appendix A). We suppose that we have a DC decomposition (u cvx k , u ccv k ) for each input k. Then we can write the following decomposition for the output of the layer:

EQUATION

In particular, for a ReLU, we can write:

EQUATION

And for a Max-Pooling layer, one can easily verify that equation ( 10) is equivalent to:

EQUATION

)

An Example of DC Networks We use the previous observations to obtain a DC decomposition in any layer. We now take the example of the neural network used for the experiments on the MNIST data set, and we show how to construct the two neural networks when optimizing W 1 , the weights of the first convolutional layer. First let us recall the architecture without decomposition: We want to optimize the first convolutional layer, therefore we fix all other parameters.

Conv1 (W 1 ) ReLU MaxPool 2x2 Conv2 (W 2 ) ReLU MaxPool 2x2 Dense1 (W 3 ) ReLU SVM 10 classes

Then we apply all operations as described in the previous paragraphs, which yields the DC networks in Figure 7 .

The network graph in Figure 7 illustrates Proposition 3 for the optimization of W 1 : suppose we are interested in f cvx (x, W 1 ), the convex part of the objective function for a given sample x, and we wish to obtain the feature vector needed to perform an update of BCFW. With a forward pass, the oracle for the latent and label variables ( ĥ, ŷ) is efficiently computed; and with a backward pass, we obtain the corresponding feature vector Ψ(x, ŷ, ĥ). Indeed, we recall from problem (8) that ( ĥ, ŷ) are the latent and label variables maximizing f cvx (x, W 1 ). Then given x, the forward pass in the DC networks sequentially solves the nested maximization: it maximizes the activation of the ReLU and MaxPooling units at each layer, thereby selecting the best latent variable ĥ at each non-linear layer, and maximizes the output of the SVM Linearizing the concave part is equivalent to fixing the activations of the DC networks, which can be done by using a fixed copy of W 1 at the linearization point (all other weights being fixed anyway). Then one can re-use the above reasoning to obtain the feature vectors for the linearized concave part. Altogether, this methodology allows our algorithm to be implemented in any standard deep learning library (our implementation is available at http://github.com/oval-group/pl-cnn).

C Experimental Details:

Hyper-parameters The hyper-parameters are obtained by cross-validation with a search on powers of 10. In this section, η will denote the initial learning rate. We denote the Softmax + Cross-Entropy loss by SCE, while SVM stands for the usual Support Vector Machines loss. One may note that the hyper-parameters are the same for both CIFAR-10 and CIFAR-100 for each combination of solver and loss. This makes sense since the initial learning rate mainly depends on the architecture of the network (and not so much on which particular images are fed to this network), which is very similar for the experiments on the CIFAR-10 and CIFAR-100 data sets.

D SVM Formulation & Dual Derivation:

Multi-Class SVM Suppose we are given a data set of N samples, for which every sample i has a feature vector φ i ∈ R d and a ground truth label y i ∈ Y. For every possible label ȳi ∈ Y, we introduce the augmented feature vector ψ i ( ȳi ) ∈ R |Y|×d containing φ i at index ȳi , -φ i at index y i , and zeros everywhere else (then ψ i (y i ) is just a vector of zeros). We also define ∆( ȳi , y i ) as the loss by choosing the output ȳi instead of the ground truth y i in our task. For classification, this is the zero-one loss for example.

The SVM optimization problem is formulated as:

min w,ξi λ 2 w 2 + 1 N N i=1 ξ i subject to: ∀i ∈ [N ], ∀ ȳi ∈ Y, ξ i ≥ w T ψ i ( ȳi ) + ∆(y i , ȳi )

Where λ is the regularization hyperparameter. We now add a proximal term to a given starting point w 0 : min

w,ξi λ 2 w 2 + µ 2 w -w 0 2 + 1 N N i=1 ξ i subject to: ∀i ∈ [N ], ∀ ȳi ∈ Y, ξ i ≥ w T ψ i ( ȳi ) + ∆(y i , ȳi )

Factorizing the second-order polynomial in w, we obtain the equivalent problem (changed by a constant):

min w,ξi λ + µ 2 w - µ λ + µ w 0 2 + 1 N N i=1 ξ i subject to: ∀i ∈ [N ], ∀ ȳi ∈ Y, ξ i ≥ w T ψ i ( ȳi ) + ∆(y i , ȳi )

For simplicity, we introduce the ratio ρ = µ λ + µ .

Dual Objective function:

The primal problem is:

min w,ξi λ + µ 2 w -ρw 0 2 + 1 N N i=1 ξ i subject to: ∀i ∈ [N ], ∀ ȳi ∈ Y, ξ i ≥ w T ψ i ( ȳi ) + ∆(y i , ȳi )

The dual problem can be written as:

max α≥0 min w,ξi λ + µ 2 w -ρw 0 2 + 1 N N i=1 ξ i + 1 N N i=1 ȳi∈Y α i ( ȳi ) ∆(y i , ȳi ) + w T ψ i ( ȳi ) -ξ i

Then we obtain the following KKT conditions:

∀i ∈ [N ], ∂• ∂ξ i = 0 -→ ȳi∈Y α i ( ȳi ) = 1 ∂• ∂w = 0 -→ w = ρw 0 - 1 N 1 λ + µ N i=1 ȳi∈Y α i ( ȳi )ψ i ( ȳi )

Aα:

We also introduce b = 1 N (∆(y i , ȳi )) i, ȳi . We define P n (Y) as the sample-wise probability simplex:

u ∈ P n (Y) if: ∀i ∈ [N ], ∀ ȳi ∈ Y, u i ( ȳi ) ≥ 0 ∀i ∈ [N ], ȳi∈Y u i ( ȳi ) = 1

We inject back and simplify to: Where:

f (α) λ + µ 2 Aα 2 -µw T 0 (Aα) -α T b

BCFW derivation We write ∇ (i) f the gradient of f w.r.t. the block (i) of variables in α, padded with zeros on blocks (j) for j = i. Similarly, A (i) and b (i) contain the rows of A and the elements of b for the block of coordinates (i) and zeros elsewhere. We can write:

∇ (i) f (α) = (λ + µ)A T (i) Aα -µA (i) w 0 -b (i)

Then the search corner for the block of coordinates (i) is given by:

s i = argmin s i < s i , ∇ (i) f (α) > = argmin s i (λ + µ)α T A T A (i) s i -µw T 0 A (i) s i -b T (i) s i

We replace:

Aα = ρw 0 -w A (i) s i = 1 N 1 λ + µ ȳi∈Y s i ( ȳi )ψ i ( ȳi ) b T (i) s i = 1 N ȳi∈Y s i ( ȳi )∆( ȳi , y i )

We then obtain: As expected, this maximum is obtained by setting s i to one at y * i = argmax ȳi∈Y w T ψ i ( ȳi ) + ∆( ȳi , y i ) and zeros elsewhere. We introduce the notation:

s i = argmin

w i = -A (i) α (i) l i = b T (i) α (i) w s = -A (i) s i l s = b T (i) s i

Then we have:

w s = - 1 N 1 λ + µ ψ(y * i ) = - 1 N 1 λ + µ ∂H i (y * i ) ∂w l s = 1 N ∆(y i , y * i )

The optimal step size in the direction of the block of coordinates (i) is given by :

γ * = argmin γ f (α + γ(s i -α i ))

The optimal step-size is given by:

γ * = < ∇ (i) f (α), s i -α i > (λ + µ) A(s i -α i ) 2

We introduce w d = -Aα = w -ρw 0 . Then we obtain: γ * = (w i -w s ) T (w -ρw 0 ) + ρw T 0 (w i -w s ) -1 λ+µ (l i -l s ) w i -w s 2 = (w i -w s ) T w -1 λ+µ (l i -l s ) w i -w s 2

And the updates are the same as in standard BCFW: In particular, we have proved Proposition (4) in this section: w is initialized to ρw 0 (KKT conditions), and the direction of the conditional gradient, w s , is given by ∂H i (y * i ) ∂w , which is independent of w 0 .

Note that the derivation of the Lagrangian dual has introduced a dual variable α i ( ȳi ) for each linear constraint of the SVM problem (this can be replaced by α i (h i , ( ȳi )) if we consider latent variables). These dual variables indicate the complementary slackness not only for the output class ȳi , but also for each of the activation which defines a piece of the piecewise linear hinge loss. Therefore a choice of α defines a path of activations.

E Sensitivity of SGD Algorithms:

Here we discuss some weaknesses of the SGD-based algorithms that we have encountered in practice for our learning objective function. These behaviors have been observed in the case of PL-CNNs, and generally may not appear in different architectures (in particular the failure to learn with high regularization goes away with the use of batch normalization layers).

E.1 Initial Learning Rate:

As mentioned in the experiments section, the choice of the initial learning rate is critical for good performance of all Adagrad, Adadelta and Adam. When the learning rate is too high, the network does not learn anything and the training and validating accuracies are stuck at random level. When it is too low, the network may take a considerably greater number of epochs to converge.

E.2 Failures to Learn:

Regularization When the regularization hyper-parameter λ is set to a value of 0.01 or higher on CIFAR-10, SGD solvers get trapped in a local minimum and fail to learn. The SGD solvers indeed fall in the local minimum of shutting down all activations on ReLUs, which provide zero-valued feature vector to the SVM loss layer (and a hinge loss of one). As a consequence, no information can be back-propagated. We plot this behavior below:

:



Figures and Tables:

Figure 1: Network architecture for the MNIST data set.

Figure2: Results on MNIST of Adagrad, Adadelta and Adam followed by LW-SVM. We verify that switching to LW-SVM leads to better solutions than running SGD longer (shaded continued plots).

Figure 3: Network architecture for the CIFAR data sets.

Figure 5: Results on CIFAR-100 of Adagrad, Adadelta and Adam followed by LW-SVM. Although Adagrad keeps improving the training objective function, it takes much longer to converge and the improvement on the training and testing accuracies rapidly become marginal.

Figure 6: Detailed network architecture for the MNIST data set.

w -ρw 0 ) T ȳi∈Y s i ( ȳi )ψ i ( ȳi ) -w T 0 ρ ȳi∈Y s i ( ȳi )ψ i ( ȳi ) -ȳi∈Y s i ( ȳi )∆( ȳi , y i ) ȳi )ψ i ( ȳi ) + ȳi∈Y s i ( ȳi )∆( ȳi , y i )  

BCFW with warm start1: Let w (0) = w 0 , ∀i ∈ [N ], w Let l (0) = 0, ∀i ∈ [N ], l ȳ i , w (k) ) and w s = --w s ) T w -1 λ+µ (l i -l s ) w i -w s 2clipped to

Results on MNIST: we compare the performance of LW-SVM with SGD algorithms on three metrics: training objective, training accuracy and testing accuracy. LW-SVM outperforms Adadelta and Adam on all three metrics, with marginal improvements since those find already very good solutions.

Table content: <table><tr><td>Solver (epochs)</td><td>Training</td><td>Training</td><td>Time (s)</td><td>Testing</td></tr><tr><td/><td colspan="2">Objective Accuracy</td><td/><td>Accuracy</td></tr><tr><td>Adagrad (200)</td><td>0.027</td><td>99.94%</td><td>707</td><td>99.22%</td></tr><tr><td>Adagrad (500)</td><td>0.024</td><td>99.96%</td><td>1759</td><td>99.20%</td></tr><tr><td>Adagrad (200) + LW-SVM</td><td>0.025</td><td>99.94%</td><td>707+366</td><td>99.21%</td></tr><tr><td>Adadelta (100)</td><td>0.049</td><td>99.56%</td><td>124</td><td>98.96%</td></tr><tr><td>Adadelta (500)</td><td>0.048</td><td>99.48%</td><td>619</td><td>99.05%</td></tr><tr><td>Adadelta (100) + LW-SVM</td><td>0.033</td><td>99.85%</td><td>124+183</td><td>99.24%</td></tr><tr><td>Adam (100)</td><td>0.038</td><td>99.76%</td><td>333</td><td>99.19%</td></tr><tr><td>Adam (500)</td><td>0.038</td><td>99.72%</td><td>1661</td><td>99.23%</td></tr><tr><td>Adam (100) + LW-SVM</td><td>0.029</td><td>99.89%</td><td>333+353</td><td>99.23%</td></tr></table>

Results on CIFAR-10: LW-SVM outperforms Adam and Adadelta on all three metrics. It improves on Adagrad, but does not outperform it -however Adagrad takes a long time to converge and does not obtain the best generalization.

Table content: <table><tr><td>Solver (epochs)</td><td>Training</td><td>Training</td><td>Time (h)</td><td>Testing</td></tr><tr><td/><td colspan="2">Objective Accuracy</td><td/><td>Accuracy</td></tr><tr><td>Adagrad (1000)</td><td>0.059</td><td>98.42%</td><td>10.58</td><td>83.15%</td></tr><tr><td>Adagrad (2000)</td><td>0.009</td><td>100.00%</td><td>21.14</td><td>83.84%</td></tr><tr><td>Adagrad (1000) + LW-SVM</td><td>0.012</td><td>100.00%</td><td>10.58+1.66</td><td>83.43%</td></tr><tr><td>Adadelta (100)</td><td>0.113</td><td>97.96%</td><td>0.83</td><td>84.42%</td></tr><tr><td>Adadelta (200)</td><td>0.054</td><td>99.83%</td><td>1.66</td><td>85.02%</td></tr><tr><td>Adadelta (100) + LW-SVM</td><td>0.038</td><td>100.00%</td><td>0.83+0.68</td><td>86.62%</td></tr><tr><td>Adam (100)</td><td>0.113</td><td>98.27%</td><td>0.83</td><td>84.18%</td></tr><tr><td>Adam (200)</td><td>0.055</td><td>99.76%</td><td>1.65</td><td>82.55%</td></tr><tr><td>Adam (100) + LW-SVM</td><td>0.034</td><td>100.00%</td><td>0.83+1.07</td><td>85.52%</td></tr></table>

Results on CIFAR-100: LW-SVM improves on all other solvers and obtains the best testing accuracy.

Table content: <table><tr><td>Solver (epochs)</td><td>Training</td><td>Training</td><td>Time (h)</td><td>Testing</td></tr><tr><td/><td colspan="2">Objective Accuracy</td><td/><td>Accuracy</td></tr><tr><td>Adagrad (1000)</td><td>0.201</td><td>95.36%</td><td>10.68</td><td>54.00%</td></tr><tr><td>Adagrad (2000)</td><td>0.044</td><td>99.98%</td><td>21.20</td><td>54.55%</td></tr><tr><td>Adagrad (1000) + LW-SVM</td><td>0.062</td><td>99.98%</td><td>10.68+3.40</td><td>53.97%</td></tr><tr><td>Adadelta (100)</td><td>0.204</td><td>95.68%</td><td>0.84</td><td>58.71%</td></tr><tr><td>Adadelta (200)</td><td>0.088</td><td>99.90%</td><td>1.67</td><td>58.03%</td></tr><tr><td>Adadelta (100) + LW-SVM</td><td>0.052</td><td>99.98%</td><td>0.84+1.48</td><td>61.20%</td></tr><tr><td>Adam (100)</td><td>0.221</td><td>95.79%</td><td>0.84</td><td>58.32%</td></tr><tr><td>Adam (200)</td><td>0.088</td><td>99.87%</td><td>1.66</td><td>57.81%</td></tr><tr><td>Adam (100) + LW-SVM</td><td>0.059</td><td>99.98%</td><td>0.84+1.69</td><td>60.17%</td></tr></table>

Hyper-parameters for the SGD solvers

Table content: <table/>

Peer review (iclr2017):
This paper proposes a new approaches for optimizing the objective of CNNs. The proposed method uses a lay-wise optimization, i.e. at each step, it optimizes the parameters in one layer of CNN while fixing the parameters in other layers. The key insight of this paper is that, for a large class of CNNs, the optimization problem at a particular can be formulated as optimizing a piecewise linear (PL) function. This PL function optimization happens to be the optimization problem commonly encountered in latent structural SVM. This connection allows this paper to borrows ideas from the latent structural SVM literature, in particular concave-convex procedure, to learn the parameters of CNNs. Overall, the paper is well-written. Traditional, CNNs and structural SVMs are almost two separate research communties. The connection of CNNs to latent structural SVM is interesting, and might bridge the gap and facilitate the transferring of ideas between these two camps. Of course, the proposed method also has some limitations. 1) It is limited to layer-wise optimization. Nowadays layer-wise optimization is essentially a coordinate descent algorithm and is not really a competitive strategy in learning CNNs. When you choose layer-wise optimization, you already lose something in terms of optimizing the objective (since you are using coordinate descent, instead of gradient descent). Of course, you also gain something since now you can guarantee that each coordinate descent step always improve the objective. It is not clear to me how the loss/gain balances each other. 2) This paper focues on improving the optimization of CNN objective. However, we all know that a better objective does not necessarily correspond to a good model (e.g. due to overfitting). Although the SGD with backprop in standard CNN learning does not always improve the solution of the objective (unlike the proposed method in this paper), but to me, this might be a good thing since it can prevent overfitting (the goal of learning is not to get better solution for the optimization problem in the first place -- the optimization problem is merely a proxy to learn a model with good generalization ability). The experiment is a bit weak. 1) Only CIFAR10 is used. This is a very small dataset by today*s standard, while CNNs are typically used in large-scale datasets, such as ImageNet. It is not clear whether the conclusions of this paper still hold when applied on ImageNet. 2) This paper only compares with a crippled variant of SGD (without batch normalization, dropout, etc). Although this paper mentions that the reason is that it wants to focus on optimization. But I mentioned earlier, SGD is not designed to purely obtain the best solution that optimizes the objective, the goal of SGD is to reasonably optimize the objective, while preventing overfitting. So the comparison to SGD purely in terms of the optimization is that meaningful in the first place.