S MOOTH L OSS F UNCTIONS FOR D EEP T OP - K C LASSIFICATION
A BSTRACT
The top- k error is a common measure of performance in machine learning and computer vision. In practice, top- k classiﬁcation is typically performed with deep neural networks trained with the cross-entropy loss.
Theoretical results indeed suggest that cross-entropy is an optimal learning objective for such a task in the limit of inﬁnite data.
In the context of limited and noisy data however, the use of a loss function that is speciﬁcally designed for top- k classiﬁcation can bring signiﬁcant improvements.
Our empirical evidence suggests that the loss function must be smooth and have non-sparse gradients in order to work well with deep neural networks.
Consequently, we introduce a family of smoothed loss functions that are suited to top- k optimization via deep learning.
The widely used cross-entropy is a special case of our family.
Evaluating our smooth loss functions is computationally challenging: a na¨ıve algorithm would require O ( (cid:0) nk (cid:1) ) operations, where n is the number of classes.
Thanks to a connection to polynomial algebra and a divideand-conquer approach, we provide an algorithm with a time complexity of O ( kn ) .
Furthermore, we present a novel approximation to obtain fast and stable algorithms on GPUs with single ﬂoating point precision.
We compare the performance of the cross-entropy loss and our margin-based losses in various regimes of noise and data size, for the predominant use case of k = 5 .
Our investigation reveals that our loss is more robust to noise and overﬁtting than cross-entropy.
I NTRODUCTION
In machine learning many classiﬁcation tasks present inherent label confusion.
The confusion can originate from a variety of factors, such as incorrect labeling, incomplete annotation, or some fundamental ambiguities that obfuscate the ground truth label even to a human expert.
For example, consider the images from the ImageNet data set (Russakovsky et al., 2015) in Figure 1, which illustrate the aforementioned factors.
To mitigate these issues, one may require the model to predict the k most likely labels, where k is typically very small compared to the total number of labels.
Then the prediction is considered incorrect if all of its k labels differ from the ground truth, and correct otherwise.
This is commonly referred to as the top- k error.
Learning such models is a longstanding task in machine learning, and many loss functions for top- k error have been suggested in the literature.
In the context of correctly labeled large data, deep neural networks trained with cross-entropy have shown exemplary capacity to accurately approximate the data distribution.
An illustration of this phenomenon is the performance attained by deep convolutional neural networks on the ImageNet challenge.
Speciﬁcally, state-of-the-art models trained with cross-entropy yield remarkable success on the top- 5 error, although cross-entropy is not tailored for top- 5 error minimization.
This phenomenon can be explained by the fact that cross-entropy is top- k calibrated for any k (Lapin et al., 2016), an asymptotic property which is veriﬁed in practice in the large data setting.
However, in cases where only a limited amount of data is available, learning large models with cross-entropy can be prone to over-ﬁtting on incomplete or noisy labels.
To alleviate the deﬁciency of cross-entropy, we present a new family of top- k classiﬁcation loss functions for deep neural networks.
Taking inspiration from multi-class SVMs, our loss creates a margin between the correct top- k predictions and the incorrect ones.
Our empirical results show that traditional top- k loss functions do not perform well in combination with deep neural networks.
We believe that the reason for this is the lack of smoothness and the sparsity of the derivatives that are used in backpropagation.
In order to overcome this difﬁculty, we smooth the loss with a temperature parameter.
The evaluation of the smooth function and its gradient is challenging, as smoothing increases the na ¨ ıve time complexity from O ( n ) to O ( (cid:0) nk (cid:1) ) .
With a connection to polynomial algebra and a divide-and-conquer method, we present an algorithm with O ( kn ) time complexity and training time comparable to cross-entropy in practice.
We provide insights for numerical stability of the forward pass.
To deal with instabilities of the backward pass, we derive a novel approximation.
Our investigation reveals that our top- k loss outperforms cross-entropy in the presence of noisy labels or in the absence of large amounts of data.
We further conﬁrm that the difference of performance reduces with large correctly labeled data, which is consistent with known theoretical results.
R ELATED W ORK
Top- k Loss Functions.
The majority of the work on top- k loss functions has been applied to shallow models: Lapin et al.
(2016) suggest a convex surrogate on the top- k loss; Fan et al.
(2017) select the k largest individual losses in order to be robust to data outliers; Chang et al.
(2017) formulate a truncated re-weighted top- k loss as a difference-of-convex objective and optimize it with the Concave-Convex Procedure (Yuille & Rangarajan, 2002); and Yan et al.
(2017) propose to use a combination of top- k classiﬁers and to fuse their outputs.
Closest to our work is the extensive review of top- k loss functions for computer vision by Lapin et al.
The authors conduct a study of a number of top- k loss functions derived from cross-entropy and hinge losses.
Interestingly, they prove that for any k , cross-entropy is top- k calibrated, which is a necessary condition for the classiﬁer to be consistent with regard to the theoretically optimal top- k risk.
In other words, cross-entropy satisﬁes an essential property to perform the optimal top- k classiﬁcation decision for any k in the limit of inﬁnite data.
This may explain why cross-entropy performs well on top- 5 error on large scale data sets.
While thorough, the experiments are conducted on linear models, or pre-trained deep networks that are ﬁne-tuned.
For a more complete analysis, we wish to design loss functions that allow for the training of deep neural networks from a random initialization.
Smoothing.
Smoothing is a helpful technique in optimization (Beck & Teboulle, 2012).
In work closely related to ours, Lee & Mangasarian (2001) show that smoothing a binary SVM with a temperature parameter improves the theoretical convergence speed of their algorithm.
Schwing et al.
(2012) use a temperature parameter to smooth latent variables for structured prediction.
Lapin et al.
(2017) apply Moreau-Yosida regularization to smooth their top- k surrogate losses.
Smoothing has also been applied in the context of deep neural networks.
In particular, Zheng et al.
(2015) and Clevert et al.
both suggest modifying the non-smooth ReLU activation to improve the training.
Gulcehre et al.
(2017) suggest to introduce “mollifyers” to smooth the objective function by gradually increasing the difﬁculty of the optimization problem.
Chaudhari et al.
(2017) add a local entropy term to the loss to promote solutions with high local entropy.
These smoothing techniques are used to speed up the optimization or improve generalization.
In this work, we show that smoothing is necessary for the neural network to perform well in combination with our loss function.
We hope that this insight can also help the design of losses for tasks other than top- k error minimization.
T OP - K SVM 3. B ACKGROUND : M ULTI -C LASS SVM
In order to build an intuition about top- k losses, we start with the simple case of k = 1 , namely multi-class classiﬁcation, where the output space is deﬁned as Y = { 1 , ..., n } .
We suppose that a vector of scores per label s ∈ R n , and a ground truth label y ∈ Y are both given.
The vector s is the output of the model we wish to learn, for example a linear model or a deep neural network.
The notation 1 will refer to the indicator function over Boolean statements (1 if true, 0 if false).
Prediction.
The prediction is given by any index with maximal score:
[Equation]
Loss.
The classiﬁcation loss incurs a binary penalty by comparing the prediction to the ground truth label.
Plugging in equation (1), this can also be written in terms of scores s as follows:
[Equation]
Surrogate.
The loss in equation (2) is not amenable to optimization, as it is not even continuous in s .
To overcome this difﬁculty, a typical approach in machine learning is to resort to a surrogate loss that provides a continuous upper bound on Λ .
Crammer & Singer (2001) suggest the following upper bound on the loss, known as the multi-class SVM loss:
[Equation]
In other words, the surrogate loss is zero if the ground truth score is higher than all other scores by a margin of at least one.
Otherwise it incurs a penalty which is linear in the difference between the score of the ground truth and the highest score over all other classes.
Rescaling.
Note that the value of 1 as a margin is an arbitrary choice, and can be changed to α for any α > 0 .
This simply entails that we consider the cost Λ of a misclassiﬁcation to be α instead of 1.
Moreover, we show in Proposition 8 of Appendix D.2 how the choices of α and of the quadratic regularization hyper-parameter are interchangeable.
3. T OP - K C LASSIFICATION
We now generalize the above framework to top- k classiﬁcation, where k ∈ { 1 , ..., n − 1 } .
We use the following notation: for p ∈ { 1 , ..., n } , s [ p ] refers to the p -th largest element of s , and s \ p to the vector ( s 1 , ..., s p − 1 , s p
+1 , ..., s n ) ∈ R n − 1 (that is, the vector s with the p -th element omitted).
The term Y ( k ) denotes the set of k -tuples with k distinct elements of Y .
Note that we use a bold font for a tuple ¯ y ∈ Y ( k ) in order to distinguish it from a single label ¯ y ∈ Y .
Prediction.
Given the scores s ∈ R n , the top- k prediction consists of any set of labels corresponding to the k largest scores:
[Equation]
Loss.
The loss depends on whether y is part of the top- k prediction, which is equivalent to comparing the k -largest score with the ground truth score:
[Equation]
Again, such a binary loss is not suitable for optimization.
Thus we introduce a surrogate loss.
Surrogate.
As pointed out in Lapin et al.
, there is a natural extension of the previous multi-class case:
[Equation]
This loss creates a margin between the ground truth and the k -th largest score, irrespectively of the values of the ( k − 1) -largest scores.
Note that we retrieve the formulation of Crammer & Singer (2001) for k = 1 .
Difﬁculty of the Optimization.
The surrogate loss l k of equation (6) suffers from two disadvantages that make it difﬁcult to optimize: (i) it is not a smooth function of s – it is continuous but not differentiable – and (ii) its weak derivatives have at most two non-zero elements.
Indeed at most two elements of s are retained by the ( · )
[ k ] and max operators in equation (6).
All others are discarded and thus get zero derivatives.
When l k is coupled with a deep neural network, the model typically yields poor performance, even on the training set.
Similar difﬁculties to optimizing a piecewise linear loss have also been reported by Li et al.
(2017) in the context of multi-label classiﬁcation.
We illustrate this in the next section.
We postulate that the difﬁculty of the optimization explains why there has been little work exploring the use of SVM losses in deep learning (even in the case k = 1 ), and that this work may help remedy it.
We propose a smoothing that alleviates both issues (i) and (ii), and we present experimental evidence that the smooth surrogate loss offers better performance in practice.
3. S MOOTH S URROGATE L OSS
Reformulation.
We introduce the following notation: given a label ¯ y ∈ Y , Y ( k )
¯ y is the subset of tuples from Y ( k ) that include ¯ y as one of their elements.
For ¯ y ∈ Y ( k ) and y ∈ Y , we further deﬁne ∆ k (¯ y , y ) (cid:44)
( y / ∈ ¯ y ) .
Then, by adding and subtracting the k − 1 largest scores of s \ y as well as s y , we obtain:
[Equation]
We give a more detailed proof of this in Appendix A.1.
Since the margin can be rescaled without loss of generality [Equation] we rewrite l k as:
[Equation]
Smoothing.
In the form of equation (8) [Equation] the loss function can be smoothed with a temperature parameter τ > 0 :
[Equation]
Note that we have changed the notation to use L k,τ to refer to the smooth loss.
In what follows, we ﬁrst outline the properties of L k,τ and its relationship with cross-entropy.
Then we show the empirical advantage of L k,τ over its non-smooth counter-part l k .
Properties of the Smooth Loss.
The smooth loss L k,τ has a few interesting properties.
First, for any τ > 0 , L k,τ is inﬁnitely differentiable and has non-sparse gradients.
Second, under mild conditions, when τ → 0 + , the non-maximal terms become negligible, therefore the summations collapse to maximizations and L k,τ → l k in a pointwise sense (Proposition 2 in Appendix A.2).
Third, L k,τ is an upper bound on l k if and only if k = 1 (Proposition 3 in Appendix A.3), but L k,τ is, up to a scaling factor, an upper bound on Λ k
(Proposition 4 in Appendix A.4).
This makes it a valid surrogate loss for the minimization of Λ k .
Relationship with Cross-Entropy.
We have previously seen that the margin can be rescaled by a factor of α > 0 .
In particular, if we scale ∆ by α → 0 + and choose a temperature τ = 1 , it can be seen that L 1 , 1 becomes exactly the cross-entropy loss for classiﬁcation.
In that sense, L k,τ is a generalization of the cross-entropy loss to: (i) different values of k ≥ 1 , (ii) different values of temperature and (iii) higher margins with the scaling α of ∆ .
For simplicity purposes, we will keep α = 1 in this work.
Experimental Validation.
In order to show how smoothing helps the training, we train a DenseNet 40-12 on CIFAR-100 from Huang et al.
(2017) with the same hyper-parameters and learning rate schedule.
The only difference with Huang et al.
(2017) is that we replace the cross-entropy loss with
L 5 ,τ for different values of τ .
We plot the top- 5 training error in Figure 2a (for each curve, the value of τ is held constant during training):
[Figure] [Figure]
Figure
Figure observe such high temperatures yield gradients that are not sparse a
We remark that the network exhibits good accuracy when τ is high enough (0.01 or larger).
For τ too small, the model fails to converge to a good critical point.
When τ is positive but small, the function is smooth but the gradients are numerically sparse (see Figure 2b), which suggests that the smoothness property is not sufﬁcient and that non-sparsity is a key factor here.
C OMPUTATIONAL C HALLENGES AND E FFICIENT A LGORITHMS 4. C HALLENGE
Experimental evidence suggests that it is beneﬁcial to use L k,τ rather than l k to train a neural network.
However, at ﬁrst glance, L k,τ may appear prohibitively expensive to compute.
Speciﬁcally, there are summations over Y ( k ) and Y ( k ) y , which have a cardinality of (cid:0) nk (cid:1) and (cid:0) nk − 1 (cid:1) respectively.
For instance for ImageNet, we have k = 5 and n = 1 , 000 , which amounts to (cid:0) nk (cid:1) (cid:39) 8 .
10 12 terms to compute and sum over for each single sample, thereby making the approach practically infeasible.
This is in stark contrast with l k , for which the most expensive operation is to compute the k -th largest score of an array of size n , which can be done in O ( n ) .
To overcome this computational challenge, we will now reframe the problem and reveal its exploitable structure.
For a vector e ∈ R n and i ∈ { 1 , .., n } , we deﬁne σ i ( e ) as the sum of all products of i distinct elements of e .
Explicitly, σ i ( e ) can be written as σ i ( e ) = (cid:80) 1 ≤ j 1 <...<
j i ≤ n e j 1 ...
e j i .
The terms σ i are known as the elementary symmetric polynomials.
We further deﬁne σ 0 ( e ) = 1 for convenience.
We now re-write L k,τ using the elementary symmetric polynomials, which appear naturally when separating the terms that contain the ground truth from the ones that do not:
[Equation]
Note that the application of exp to vectors is meant in an element-wise fashion.
The last equality of equation (10) reveals that the challenge is to efﬁciently compute σ k − 1 and σ k , and their derivatives for the optimization.
While there are existing algorithms to evaluate the elementary symmetric polynomials, they have been designed for computations on CPU with double ﬂoating point precision.
For the most recent work, see Jiang et al.
To efﬁciently train deep neural networks with L k,τ , we need algorithms that are numerically stable with single ﬂoating point precision and that exploit GPU parallelization.
In the next sections, we design algorithms that meet these requirements.
The ﬁnal performance is compared to the standard alternative algorithm in Appendix B.3.
4. F ORWARD C OMPUTATION
We consider the general problem of efﬁciently computing ( σ k − 1 , σ k ) .
Our goal is to compute σ k ( e ) , where e ∈ R n and k (cid:28) n .
Since this algorithm will be applied to e = exp
( s \ y /kτ )
(see equation (10)), we can safely assume e i (cid:54)
=
for all i ∈ (cid:74) 1 , n (cid:75) .
The main insight of our approach is the connection of σ i ( e ) to the polynomial:
[Equation]
Indeed, if we expand P to α
+ α 1 X
+ ...
+ α n X n , Vieta’s formula gives the relationship:
[Equation]
Therefore, it sufﬁces to compute the coefﬁcients α n − k to obtain the value of σ k ( e ) .
To compute the expansion of P , we can use a divide-and-conquer approach with polynomial multiplications when merging two branches of the recursion.
This method computes all ( σ i ) 1 ≤ i ≤ n instead of the only ( σ i )
k − 1 ≤ i ≤ k that we require.
Since we do not need σ i ( e ) for i > k , we can avoid computations of all coefﬁcients for a degree higher than n − k . However, typically k (cid:28) n .
For example, in ImageNet, we have k = 5 and n = 1 , 000 , therefore we have to compute coefﬁcients up to a degree 995 instead of 1,000, which is a negligible improvement.
To turn k (cid:28) n to our advantage, we notice that σ i ( e ) = σ n ( e ) σ n − i (1 / e ) .
Moreover, σ n ( e ) = n (cid:81) i =1 e
i can be computed in O ( n ) .
Therefore we introduce the polynomial:
[Equation]
Then if we expand Q to β 0 + β 1 X
+ ... + β n X n , we obtain with Vieta’s formula again: [Equation]
[Equation]
Subsequently, in order to compute σ k ( e ) , we only require the k ﬁrst coefﬁcients of Q , which is very efﬁcient when k is small in comparison with n .
This results in a time complexity of O ( kn ) (Proposition 5 in Appendix B.1).
Moreover, there are only O (log( n )) levels of recursion, and since every level can have its operations parallelized, the resulting algorithm scales very well with n when implemented on a GPU (see Appendix B.3.2 for practical runtimes).
The algorithm is described in Algorithm 1: step 2 initializes the polynomials for the divide and conquer method.
While the polynomial has not been fully expanded, steps 5-6 merge branches by performing the polynomial multiplications (which can be done in parallel).
Step 10 adjusts the coefﬁcients using equation (14).
We point out that we could obtain an algorithm with a time complexity of O ( n log( k ) 2 ) if we were using Fast Fourier Transform for polynomial multiplications in steps 5-6.
Since we are interested in the case where k is small (typically 5), such an improvement is negligible.
Algorithm 1 Forward Pass
Require: e ∈ ( R ∗ + ) n , k ∈ N ∗ 1: t ←2: P ( t ) i ← (1 , 1 /e i ) for i ∈ (cid:74) 1 , n (cid:75) (cid:46) Initialize n polynomials to X + 1 e i (encoded by coefﬁcients) 3: p ← n (cid:46) Number of polynomials 4: while p > 1 do (cid:46)
Merge branches with polynomial multiplications 5:
P ( t +1)← P ( t ) 1 ∗ P ( t )(cid:46) Polynomial multiplication up to degree k ...
P ( t +1)
( p − 1) //
2 ← P ( t ) p − 1 ∗ P ( t ) p
(cid:46) Polynomial multiplication up to degree k 7: t ← t +8: p ← ( p − 1) //(cid:46)
Update number of polynomials 9: end while 10: P ( t +1) ← P ( t ) × n (cid:81) i
=1 e i (cid:46)
Recover σ i ( e ) =
σ n − i (1 / e ) σ n ( e ) 11: return P ( t +1)
Obtaining numerical stability in single ﬂoating point precision requires special attention: the use of exponentials with an arbitrarily small temperature parameter is fundamentally unstable.
In Appendix
B.2.1, we describe how operating in the log-space and using the log-sum-exp trick alleviates this issue.
The stability of the resulting algorithm is empirically veriﬁed in Appendix B.3.3.
4. B ACKWARD C OMPUTATION
A side effect of using Algorithm 1 is that a large number of buffers are allocated for automatic differentiation: for each addition in log-space, we apply log and exp operations, each of which needs to store values for the backward pass.
This results in a signiﬁcant amount of time spent on memory allocations, which become the time bottleneck.
To avoid this, we exploit the structure of the problem and design a backward algorithm that relies on the results of the forward pass.
By avoiding the memory allocations and considerably reducing the number of operations, the backward pass is then sped up by one to two orders of magnitude and becomes negligible in comparison to the forward pass.
We describe our efﬁcient backward pass in more details below.
First, we introduce the notation for derivatives:
[Equation]
We now observe that:
[Equation]
In other words, equation (16) states that δ j,i , the derivative of σ j ( e ) with respect to e i , is the sum of product of all ( j − 1)
-tuples that do not include e i .
One way of obtaining σ j − 1 ( e \ i ) is to compute a forward pass for e \ i , which we would need to do for every i ∈ (cid:74) 1 , n (cid:75) .
To avoid such expensive computations, we remark that σ j ( e ) can be split into two terms: the ones that contain e i (which can expressed as e i σ j − 1 ( e \ i ) ) and the ones that do not (which are equal to σ j ( e \ i ) by deﬁnition).
This gives the following relationship:
[Equation]
Simplifying equation (17) using equation (16), we obtain the following recursive relationship:
[Equation]
Since the ( σ j ( e )) 1 ≤ i ≤ k have been computed during the forward pass, we can initialize the induction with δ 1 ,i = 1 and iteratively compute the derivatives δ j,i for j ≥ 2 with equation (18).
This is summarized in Algorithm 2.
Algorithm 2 Backward Pass
Require:
e , ( σ j ( ≤ j ≤ k have been computed in the forward pass
Algorithm 2 is subject to numerical instabilities (Observation 1 in Appendix B.2.2).
In order to avoid these, one solution is to use equation (16) for each unstable element, which requires numerous forward passes.
To avoid this inefﬁciency, we provide a novel approximation in Appendix B.2.2: the computation can be stabilized by an approximation with signiﬁcantly smaller overhead.
E XPERIMENTS
Theoretical results suggest that Cross-Entropy (CE) is an optimal classiﬁer in the limit of inﬁnite data, by accurately approximating the data distribution.
In practice, the presence of label noise makes the data distribution more complex to estimate when only a ﬁnite number of samples is available.
For these reasons, we explore the behavior of CE and L k,τ when varying the amount of label noise and the training data size.
For the former, we introduce label noise in the CIFAR-100 data set (Krizhevsky, 2009) in a manner that would not perturb the top- 5 error of a perfect classiﬁer.
For the latter, we vary the training data size on subsets of the ImageNet data set (Russakovsky et al., 2015).
In all the following experiments, the temperature parameter is ﬁxed throughout training.
This choice is discussed in Appendix D.1.
The algorithms are implemented in Pytorch (Paszke et al., 2017) and are publicly available at https://github.com/oval-group/smooth-topk .
Experiments on CIFAR-100 and ImageNet are performed on respectively one and two Nvidia Titan Xp cards.
5. CIFAR-100 WITH NOISE
Data set.
In this experiment, we investigate the impact of label noise on CE and L 5 , 1 .
The CIFAR100 data set contains 60,000 RGB images, with 50,000 samples for training-validation and 10,000 for testing.
There are 20 “coarse” classes, each consisting of 5 “ﬁne” labels.
For example, the coarse class “people” is made up of the ﬁve ﬁne labels “baby”, “boy”, “girl”, “man” and “woman”.
In this set of experiments, the images are centered and normalized channel-wise before they are fed to the network.
We use the standard data augmentation technique with random horizontal ﬂips and random crops of size 32 × 32 on the images padded with 4 pixels on each side.
We introduce noise in the labels as follows: with probability p , each ﬁne label is replaced by a ﬁne label from the same coarse class.
This new label is chosen at random and may be identical to the original label.
Note that all instances generated by data augmentation from a single image are assigned the same label.
The case p = 0 corresponds to the original data set without noise, and p =to the case where the label is completely random (within the ﬁne labels of the coarse class).
With this method, a perfect top- 5 classiﬁer would still be able to achieve 100 % accuracy by systematically predicting the ﬁve ﬁne labels of the unperturbed coarse label.
Methods.
To evaluate our loss functions, we use the architecture DenseNet 40-40 from Huang et al.
and we use the same hyper-parameters and learning rate schedule as in Huang et al.
The temperature parameter is ﬁxed to one.
When the level of noise becomes non-negligible, we empirically ﬁnd that CE suffers from over-ﬁtting and signiﬁcantly beneﬁts from early stopping – which our loss does not need.
Therefore we help the baseline and hold out a validation set of 5, images, on which we monitor the accuracy across epochs.
Then we use the model with the best topvalidation accuracy and report its performance on the test set.
Results are averaged over three runs with different random seeds.
[Table]
Results.
As seen in Table 1, L 5 , 1 outperforms CE on the top- 5 testing accuracy when the labels are noisy, with an improvement of over 5% in the case p = 1 .
When there is no noise in the labels, CE provides better top- 1 performance, as expected.
It also obtains a better top- 5 accuracy, although by a very small margin.
Interestingly, L 5 , 1 outperforms CE on the top- 1 error when there is noise, although L 5 , 1 is not a surrogate for the top- 1 error.
For example when p = 0 . 8 , L 5 , 1 still yields an accuracy of 55.85%, as compared to 35.53% for CE.
This suggests that when the provided label is only informative about top- 5 predictions (because of noise or ambiguity), it is preferable to use L 5 , 1 .
5. I MAGE N ET
Data set.
As shown in Figure 1, the ImageNet data set presents different forms of ambiguity and noise in the labels.
It also has a large number of training samples, which allows us to explore different regimes up to the large-scale setting.
Out of the 1.28 million training samples, we use subsets of various sizes and always hold out a balanced validation set of 50,000 images.
We then report results on the 50,000 images of the ofﬁcial validation set, which we use as our test set.
Images are resized so that their smaller dimension is 256, and they are centered and normalized channel-wise.
At training time, we take random crops of 224 × 224 and randomly ﬂip the images horizontally.
At test time, we use the standard ten-crop procedure (Krizhevsky et al., 2012).
We report results for the following subset sizes of the data: 64k images (5%), 128k images (10%), 320k images (25%), 640k images (50%) and ﬁnally the whole data set (1.28M − 50k =
1.23M images for training).
Each strict subset has all 1,000 classes and a balanced number of images per class. The largest subset has the same slight unbalance as the full ImageNet data set.
Methods.
In all the following experiments, we train a {+ResNet-
+} (He et al., 2016), adapting the protocol of the ImageNet experiment in Huang et al.
In more details, we optimize the model with Stochastic Gradient Descent with a batch-size of 256, for a total of 120 epochs.
We use a Nesterov momentum of 0.9.
The temperature is set to 0.1 for the SVM loss (we discuss the choice of the temperature parameter in Appendix D.1).
The learning rate is divided by ten at epochs 30, 60 and 90, and is set to an initial value of 0.1 for CE and 1 for L 5 , 0 . The quadratic regularization hyper-parameter is set to 0 . 0001 for CE. For L 5 , 0 . 1 , it is set to 0 .
000025 to preserve a similar relative weighting of the loss and the regularizer.
For both methods, training on the whole data set takes about a day and a half (it is only 10% longer with L 5 , 0 .
1 than with CE).
As in the previous experiments, the validation top- 5 accuracy is monitored at every epoch, and we use the model with best topvalidation accuracy to report its test error.
Probabilities for Multiple Crops.
Using multiple crops requires a probability distribution over labels for each crop.
Then this probability is averaged over the crops to compute the ﬁnal prediction.
The standard method is to use a softmax activation over the scores.
We believe that such an approach is only grounded to make top- 1 predictions.
The probability of a label ¯ y being part of the topprediction should be marginalized over all combinations of 5 labels that include ¯ y as one of their elements.
This can be directly computed with our algorithms to evaluate σ k and its derivative.
We refer the reader to Appendix C for details.
All the reported results of top- 5 error with multiple crops are computed with this method.
This provides a systematic boost of at least 0.2% for all loss functions.
In fact, it is more beneﬁcial to the CE baseline, by up to 1% in the small data setting.
[Table]
Results.
The results of Table 2 conﬁrm that L 5 , 0 .
1 offers better top- 5 error than CE when the amount of training data is restricted.
As the data set size increases, the difference of performance becomes very small, and CE outperforms L 5 , 0 .
1 by an insigniﬁcant amount in the full data setting.
C ONCLUSION
This work has introduced a new family of loss functions for the direct minimization of the top- k error (that is, without the need for ﬁne-tuning).
We have empirically shown that non-sparsity is essential for loss functions to work well with deep neural networks.
Thanks to a connection to polynomial algebra and a novel approximation, we have presented efﬁcient algorithms to compute the smooth loss and its gradient.
The experimental results have demonstrated that our smooth top- 5 loss function is more robust to noise and overﬁtting than cross-entropy when the amount of training data is limited.
We have argued that smoothing the surrogate loss function helps the training of deep neural networks.
This insight is not speciﬁc to top- k classiﬁcation, and we hope that it will help the design of other surrogate loss functions.
In particular, structured prediction problems could beneﬁt from smoothed
SVM losses.
How to efﬁciently compute such smooth functions could open interesting research problems. A CKNOWLEDGMENTS
This work was supported by the EPSRC grants AIMS CDT EP/L015987/1, Seebibyte EP/M013774/1,
EP/P020658/1 and TU/B/000048, and by Yougov.
Many thanks to A. Desmaison and R. Bunel for the helpful discussions.
A PPENDIX A Surrogate Losses: Properties
A.1 Reformulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.2 Point-wise Convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.3 Bound on Non-Smooth Function . . . . . . . . . . . . . . . . . . . . . . . . . . . A.4 Bound on Prediction Loss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
B Algorithms: Properties & Performance
B.1 Time Complexity . .
B.2 Numerical Stability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
B.2.
Forward Pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
B.2.
Backward Pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
B.3 A Performance Comparison with the Summation Algorithm . . . . . . . . . . . .
B.3.
Summation Algorithm . .
B.3.
Speed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
B.3.
Stability . .
C Top-k Prediction: Marginalization with the Elementary Symmetric Polynomials
D Hyper-Parameters & Experimental Details
D.1 The Temperature Parameter
D.
Optimization and Learning
D
2 Illustration on CIFAR
D
3 To Anneal or Not To
Anneal . . . . . . . . . . . . . . . . . . . . . . . . .
D
4 Practical Methodology
D
2 The Margin
D
2.1 Relationship with Squared Norm Regularization
D
2 Experiment on ImageNet
D.3 Supplementary Details
A S URROGATE L OSSES : P ROPERTIES
In this section, we ﬁx n the number of classes.
We let τ > 0 and k ∈ { 1 , ..., n − 1 } .
All following results are derived with a loss l k deﬁned as in equation (8):
[Equation]
A. R EFORMULATION
Proposition 1.
We can equivalently re-write l k as:
[Equation]
Proof.
l k ( s , y )
=
max
[Equation]
[Equation]
= max
[Equation]
A. P OINT - WISE C ONVERGENCE
Lemma 1.
Let n ≥ 2 and e ∈ R n .
Assume that the largest element of e is greater than its second largest element: e [1] > e [2] .
Then lim τ →τ>τ log (cid:18) n (cid:80) i =1 exp( e i /τ ) (cid:19)
= e [1] .
Proof.
For simplicity of notation, and without loss of generality, we suppose that the elements of e are sorted in descending order.
Then for i ∈ { 2 , ..n } , we have e i − e 1 ≤ e 2 − e 1 < 0 by assumption, and thus ∀ i ∈ { 2 , ..n } , lim τ →τ>exp(( e i − e 1 ) /τ )
= 0 .
Therefore: lim
[Equation]
→ 0 τ>n (cid:88) i = exp(( e i − e 1 ) /τ )
=
n (cid:88) i = lim
[Equation]
And thus:
[Equation]
The result follows by noting that:
[Equation]
Proposition 2.
Assume that s [ k − 1] > s [ k ] and that s [ k ] > s [ k +1] or 1 k s y > 1 + 1 k s [ k ] .
Then lim τ → 0 τ> 0 L k,τ ( s , y ) =
l k ( s , y ) .
Proof.
From s [ k ] > s [ k +1] or 1 k s y > 1 + 1 k s [ k ] , one can see that max ¯ y ∈Y ( k ) (cid:110)
∆ k (¯ y , y ) + 1 k (cid:80) j ∈ ¯ y s j (cid:111) is a strict maximum.
Similarly, from s [ k − 1] > s [ k ] , we have that max ¯ y ∈Y ( k ) y (cid:110) 1 k (cid:80)
j ∈ ¯ y s j (cid:111) is a strict maximum.
Since L k,τ can be written as:
[Equation]
the result follows by two applications of Lemma 1.
A
B OUND ON N ON -S MOOTH F UNCTION
Proposition 3.
L k,τ is an upper bound on l k if and only if k = 1 .
Proof.
Suppose k = 1 .
Let s ∈ R n and y ∈ Y .
We introduce y ∗ =
argmax ¯ y ∈Y { ∆ 1 (¯ y, y )
+ s ¯ y } .
Then we have:
[Equation]
Now suppose k ≥ 2 .
We construct an example ( s , y ) such that L k,τ ( s , y ) <
l k ( s , y ) .
For simplicity, we set y = 1 .
Then let s
= α , s i = β for i ∈ { 2 , ..., k + 1 } and s i
=
−∞ for i ∈ { k + 2 , ..., n } .
The variables α and β are our degrees of freedom to construct the example.
Assuming inﬁnite values simpliﬁes the analysis, and by continuity of L k,τ and l k , the proof will hold for real values sufﬁciently small.
We further assume that 1 + 1 k ( β − α ) > 0 .
Then can write l k ( s , y ) as:
[Equation]
Exploiting the fact
that exp( s i /τ ) =
for i ≥ k + 2 , we have:
[Equation]
And:
[Equation]
This allows us to write L k,τ as:
[Equation]
[Equation] We introduce x = 1 + 1 k ( β − α ) .
Then we have:
[Equation]
And:
[Equation]
For any value x > 0 , we can ﬁnd ( α, β )
∈ R 2 such that x = 1+ 1 k ( β − α ) and that all our hypotheses are veriﬁed.
Consequently [Equation] we only have to prove that there exists x > 0 such that:
[Equation]
We show that lim x →∞ ∆( x ) < [Equation] which will conclude the proof by continuity of ∆ .
[Equation]
A. B OUND ON P REDICTION L OSS
Lemma 2.
Let ( p, q ) ∈ N 2 such that p ≤ q − 1 and q ≥ 1 .
Then (cid:0) qp (cid:1) ≤ q (cid:0) qp +1 (cid:1) .
Proof.
[Equation]
This is a monotonically increasing function of p ≤ q − 1 , therefore it is upper bounded by its maximal value at p =
q − 1 :
[Equation]
Lemma 3. Assume that y / ∈ P k ( s ) .
Then we have:
[Equation]
Proof.
Let j ∈ (cid:74) 0 , k − 1 (cid:75) .
We introduce the random variable U j , whose probability distribution is uniform over the set U j (cid:44) {
¯ y ∈ Y ( k ) y :
¯ y ∩ P k ( s ) = j } .
Then V j is the random variable such that
V j | U j replaces y from U j with a value drawn uniformly from P k ( s ) .
We denote by V j the set of values taken by V j with non-zero probability.
Since V j replaces the ground truth score by one of the values of P k ( s ) , it can be seen that:
[Equation]
Furthermore, we introduce the scoring function f : ¯ y ∈ Y ( k ) (cid:55)→ exp( 1 kτ
[Equation]
j ∈ ¯ y s j ) .
Since P k ( s ) is the set of the k largest scores and
y / ∈ P k ( s ) , we have that: [Equation]
probability
[Equation]
Therefore we also have that:
[Equation]
This ﬁnally gives us:
[Equation]
Making the (uniform) probabilities explicit, we obtain:
[Equation]
To derive the set cardinalities
[Equation]
we rewrite U j and V j as:
[Equation]
Therefore we have that:
[Equation]
And:
[Equation]
Therefore:
[Equation]
by Lemma 2 .
[Equation]
Combining with equation (42) [Equation] we obtain:
[Equation]
We sum over j ∈ (cid:74) 0 , k − 1 (cid:75) , which yields:
[Equation]
Finally, we note that {U j } 0 ≤ j ≤ k − 1 and {V j } 0 ≤ j ≤ k − 1 are respective partitions of Y ( k ) y and Y ( k ) \Y ( k ) y , which gives us the ﬁnal result:
[Equation]
Proposition 4.
L k,τ is, up to a scaling factor, an upper bound on the prediction loss Λ k :
[Equation]
Proof.
Suppose that Λ k ( s , y ) = 0 .
Then the inequality is trivial because L k,τ ( s , y ) ≥ 0 .
We now assume that Λ k ( s , y )
= 1 .
Then there exist at least k higher scores than s y .
To simplify indexing, we introduce Z ( k ) y
= Y ( k ) \Y ( k ) y and T k
the set of k labels corresponding to the k -largest scores.
By assumption, y / ∈ T k since y is misclassiﬁed.
We then write:
[Equation]
Thanks to Lemma 3, we have:
[Equation]
Injecting this back into (51):
[Equation]
And back to the original loss:
[Equation]
B A LGORITHMS : P ROPERTIES & P ERFORMANCE B. T IME C OMPLEXITY
Lemma 4.
Let P and Q be two polynomials of degree p and q .
The time complexity of obtaining the ﬁrst r coefﬁcients of PQ is O
(min { r, p } min { r, q } ) .
Proof.
The multiplication of two polynomials can be written as the convolution of their coefﬁcients, which can be truncated at degree r for each polynomial.
Proposition 5.
The time complexity of Algorithm 1 is O ( kn ) .
Proof.
Let N = log 2 ( n ) , or equivalently n = 2 N .
With the divide-and-conquer algorithm, the complexity of computing the k ﬁrst coefﬁcients of P can be written as:
[Equation]
Indeed we decompose P = Q 1 Q 2 , with each Q i of degree n/ 2 , and for these we compute their k ﬁrst coefﬁcients in T ( n 2 ) .
Then given the k ﬁrst coefﬁcients of Q 1 and Q 2 , the k ﬁrst coefﬁcients of
P are computed in O (min { k, n } 2 ) by Lemma 4.
Then we can write:
[Equation]
By summing these terms, we obtain T ( k, n ) =
2 N T ( k, 1) + N − 1 (cid:80) [Equation] j [Equation]
k
[Equation]
2 j (cid:111) 2 .
Let n 0 ∈ N such that n
[Equation]
≤ n 2 n 0 .
In loose notation, we have kn
[Equation]
n = O (1) .
Then we can write: N
[Equation]
(cid:88)
[Equation]
Thus ﬁnally:
[Equation]
B. N UMERICAL S TABILITY B.2. F ORWARD P ASS
In order to ensure numerical stability of the computation, we maintain all computations in the log space: for a multiplication exp( x 1 ) exp( x 2 ) , we actually compute and store x 1 + x 2 ; for an addition exp( x 1 ) + exp( x 2 ) we use the “log-sum-exp” trick: we compute m = max { x 1 , x 2 } , and store m +log(exp
x 1 − m )
+exp( x 2 − m )) , which guarantees stability of the result.
These two operations sufﬁce to describe the forward pass.
B.2. B ACKWARD P ASS
Observation 1.
The backward recursion of Algorithm 2 is unstable when e i (cid:29) 1 and e i (cid:29) max p (cid:54)
= i { e p } .
Sketch of Proof.
To see that, assume that when we compute ( n (cid:80) p =1 e p ) − e i , we make a numerical error in the order of (cid:15) (e.g (cid:15) (cid:39) 10 − 5 for single ﬂoating point precision).
With the numerical errors, we obtain approximate ˆ δ as follows:
[Equation]
Since e i (cid:29) 1 , we quickly obtain unstable results.
Deﬁnition 1.
For p ∈ { 0 , ..., n − k } , we deﬁne the p -th order approximation to the gradient as:
[Equation]
Proposition 6.
If we approximate the gradient by its p -th order approximation as deﬁned in equation (60)
[Equation]
the absolute error is:
[Equation]
Proof. We remind equation (18), which gives a recursive relationship for the gradients:
[Equation]
This can be re-written as:
[Equation]
We write σ k + p ( e \ i )
=
δ k + p
{++
+}
i , and the result follows by repeated applications of equation (62) for j ∈ { k + 1 , k + 2 , ..., k + p + 1 } .
Intuition.
We have seen in Observation 1 that the recursion tends to be unstable for δ j,i when e i is among the largest elements.
When that is the case, the ratio σ k + p ( e \ i ) e {+p +
 i decreases quickly with p .+}
This has two consequences: (i) the sum of equation (60) is stable to compute because the summands have different orders of magnitude and (ii) the error becomes small.
Unfortunately, it is difﬁcult to upper-bound the error of equation (61) by a quantity that is both measurable at runtime (without expensive computations) and small enough to be informative.
Therefore the approximation error is not controlled at runtime. In practice, we detect the instability of δ k,i : numerical issues arise if subtracted terms have a very small relative difference.
For those unstable elements we use the p -th order approximation (to choose the value of p , a good rule of thumb is p (cid:39) 0 .
2 k ).
We have empirically found out that this heuristic works well in practice.
Note that this changes the complexity of the forward pass to O (( k + p ) n ) since we need p additional coefﬁcients during the backward.
If p (cid:39) 0 .
2 k , this increases the running time of the forward pass by 20%, which is a moderate impact.
B. A P ERFORMANCE C OMPARISON WITH THE S UMMATION A LGORITHM B.3. S UMMATION A LGORITHM
The Summation Algorithm (SA) is an alternative to the Divide-and-Conquer (DC) algorithm for the evaluation of the elementary symmetric polynomials.
It is described for instance in (Jiang et al., 2016).
The algorithm can be summarized as follows:
Implementation.
Note that the inner loop can be parallelized, but the outer one is essentially sequential.
In our implementation for
speed
comparisons, the inner loop is parallelized and a buffer is pre-allocated for the σ j,i .
Require: e ∈ R n , k ∈ N ∗ 1: σ 0 ,i ← 1 for 1 ≤ i ≤ n (cid:46) σ j,i =
σ j ( e 1 , . . .
, e i ) 2: σ j,i ← 0 for i < j (cid:46) Do not deﬁne values for i < j (meaningless) 3: σ 1 , 1 ← e(cid:46)
Initialize recursion 4: for i ∈ (cid:74) 2 , n (cid:75) do 5: m ← max { 1 , i + k − n } 6:
M ← min { i, k } 7: for i ∈ (cid:74) m, M (cid:75) do 8: σ j,i ← σ j,i −
+ e i σ j − 1 ,i − 1 9: end for 10: end for 11: return σ k,n
B.3. S PEED
We compare the execution time of the DC and SA algorithms on a GPU (Nvidia Titan Xp).
We use the following parameters: k = 5 , a batch size of 256 and a varying value of n .
The following timings are given in seconds, and are computed as the average of 50 runs.
In Table 3, we compare the speed of Summation and DC for the evaluation of the forward pass.
In Table 4, we compare the speed of the evaluation of the backward pass using Automatic Differentiation (AD) and our Custom Algorithm (CA) (see Algorithm 2). [Table]
SA
[Table]
We remind that both algorithms have a time complexity of O ( kn ) .
SA provides little parallelization (the parallelizable inner loop is small for k (cid:28) n ), which is reﬂected in the runtimes.
On the other hand,
DC is a recursive algorithm with O (log( n )) levels of recursion, and all operations are parallelized at each level of the recursion.
This allows DC to have near-logarithmic effective scaling with n , at least in the range { 100 − 10 , 000 } .
[Table]
These runtimes demonstrate the advantage of using Algorithm 2 instead of automatic differentiation.
In particular, we see that in the use case of ImageNet ( n = 1 , 000 ), the backward computation changes from being 8x slower than the forward pass to being 3x faster.
B.3. S TABILITY
We now investigate the numerical stability of the algorithms.
Here we only analyze the numerical stability, and not the precision of the algorithm.
We point out that compensation algorithms are useful to improve the precision of SA but not its stability.
Therefore they are not considered in this discussion.
Jiang et al.
(2016) mention that SA is a stable algorithm, under the assumption that no overﬂow or underﬂow is encountered.
However this assumption is not veriﬁed in our use case, as we demonstrate below.
We consider that the algorithm is stable if no overﬂow occurs in the algorithm (underﬂows are not an issue for our use cases).
We stress out that numerical stability is critical for our machine learning context: if an overﬂow occurs, the weights of the learning model inevitably diverge to inﬁnite values.
To test numerical stability in a representative setting of our use cases, we take a random mini-batch of 128 images from the ImageNet data set and forward it through a pre-trained ResNet-18 to obtain a vector of scores per sample.
Then we use the scores as an input to the SA and DC algorithms, for various values of the temperature parameter τ .
We compare the algorithms with single (S) and double (D) ﬂoating point precision.
[Table]
By operating in the log-space, DC is signiﬁcantly more stable than SA.
In this experimental setting,
DC log is stable in single ﬂoating point precision until τ = 10 − 36 .
C T OP - K P REDICTION : M ARGINALIZATION WITH THE E LEMENTARY S YMMETRIC P OLYNOMIALS
We consider the probability of label i being part of the ﬁnal top- k prediction.
To that end, we marginalize over all k -tuples that contain i as one of their element.
Then the probability of selecting label i for the top- k prediction can be written as:
[Equation]
Proposition 7.
The unnormalized probability can be computed as:
[Equation]
Proof.
[Equation]
Finally we can rescale the unnormalized probability p ( k ) i by σ k (exp( s )) since the latter quantity is independent of i .
We obtain:
[Equation]
NB.
We prefer to use d log σ i (exp( s ))
ds i rather than dσ i (exp( s ))
ds i for stability reasons.
Once the unnormalized probabilities are computed, they can be normalized by simply dividing by their sum.
D H YPER -P ARAMETERS & E XPERIMENTAL D ETAILS D. T HE T EMPERATURE P ARAMETER
In this section, we discuss the choice of the temperature parameter.
Note that such insights are not necessarily conﬁned to a top- k minimization: we believe that these ideas generalize to any loss that is smoothed with a temperature parameter.
D.1. O PTIMIZATION AND L EARNING
When the temperature τ has a low value, propositions 3 and 4 suggest that L k,τ is a sound learning objective.
However, as shown in Figure 2a, optimization is difﬁcult and can fail in practice.
Conversely, optimization with a high value of the temperature is easy, but uninformative about the learning: then
L k,τ is not representative of the task loss we wish to learn.
In other words, there is a trade-off between the ease of the optimization and the quality of the surrogate loss in terms of learning.
Therefore, it makes sense to use a low temperature that still permits satisfactory optimization.
D.1. I LLUSTRATION ON CIFAR-
In Figure 2a, we have provided the plots of the training objective to illustrate the speed of convergence.
In Table 6, we give the training and validation accuracies to show the inﬂuence of the temperature:
[Table]
D.1. T O A NNEAL OR N OT T O A NNEAL
The choice of temperature parameter can affect the scale of the loss function.
In order to preserve a sensible trade-off between regularizer and loss, it is important to adjust the regularization hyperparameter(s) accordingly (the value of the quadratic regularization for instance).
Similarly, the energy landscape may vary signiﬁcantly for a different value of the temperature, and the learning rate may need to be adapted too.
Continuation methods usually rely on an annealing scheme to gradually improve the quality of the approximation.
For this work, we have found that such an approach required heavy engineering and did not provide substantial improvement in our experiments.
Indeed, we have mentioned that other hyper-parameters depend on the temperature, thus these need to be adapted dynamically too.
This requires sensitive heuristics.
Furthermore, we empirically ﬁnd that setting the temperature to an appropriate ﬁxed value yields the same performance as careful ﬁne-tuning of a pre-trained network with temperature annealing.
D.1. P RACTICAL M ETHODOLOGY
We summarize the methodology that reﬂects the previous insights and that we have found to work well during our experimental investigation.
First, the temperature hyper-parameter is set to a low ﬁxed value that allows for the model to learn on the training data set.
Then other hyper-parameters, such as quadratic regularization and learning rate are adapted as usual by cross-validation on the validation set.
We believe that the optimal value of the temperature is mostly independent of the architecture of the neural network, but is greatly inﬂuenced by the values of k and n (see how these impact the number of summands involved in L k,τ , and therefore its scale).
D. T HE M ARGIN D.2. R ELATIONSHIP WITH S QUARED N ORM R EGULARIZATION
In this subsection, we establish the relationship between hyper-parameters of the margin and of the regularization with a squared norm.
Typically the regularizing norm is the Frobenius norm in deep learning, but the following results will follow for any norm (cid:107) · (cid:107) .
Although we prove the result for our top- k loss, we also point out that these results easily generalize to any linear latent structural SVM.
First, we make explicit the role of α in l k with an overload of notation:
[Equation]
where α is a non-negative real number.
Now consider the problem of learning a linear top- k SVM on a dataset ( x i , y i ) 1 ≤ i ≤ N ∈ (cid:0)
R d × { 1 , ..., n } (cid:1) N .
We (hyper-)parameterize this problem by λ and α : ( P
[Equation]
Deﬁnition 2.
Let λ 1 , λ 2 , α 1 , α 2 ≥ 0 .
We say that ( P λ 1 ,α 1 ) and ( P λ 2 ,α 2 ) are equivalent if there exists γ > 0 , ν ∈ R such that:
[Equation]
is a solution of
[Equation]
P λ
[Equation]
[Equation]
w
[Equation]
ν ) is a solution of
[Equation]
P
[Equation]
[Equation]
Justiﬁcation.
This deﬁnition makes sense because for γ > 0 , ν ∈ R , ( γ w + ν ) has the same decision boundary as w .
In other words, equivalent problems yield equivalent classiﬁers.
Proposition 8.
Let λ, α ≥ 0 .
If α > 0 and λ > 0 , then problem ( P λ,α ) is equivalent to problems ( P αλ, 1 ) and ( P 1 ,αλ ) .
If α = 0 or λ = 0 , then problem ( P λ,α ) is equivalent to problem ( P 0 , 0 ) .
Proof.
Let w ∈ R d × n .
We introduce a constant β > 0 .
Then we can successively write: w is a solution to ( P λ,α )
⇐⇒ w is a solution to
[Equation]
⇐⇒ w is a solution to
[Equation]
⇐⇒ w is a solution to
[Equation]
⇐⇒ w is a solution to
[Equation]
⇐⇒β w is a solution to min
[Equation]
⇐⇒
β w is a solution to ( P βλ, αβ ) .
[Equation]
This holds for any β > 0 .
If α > 0 and λ > 0 , we show equivalence with ( P αλ, 1 ) by setting β to α and with ( P 1 ,αλ ) by setting β to 1 λ .
If α = 0 , then α β = 0 for any β > 0 and we can choose β as small as needed to make βλ arbitrarily small.
{+If λ = 0 , βλ = 0 for any β > 
+}
and we can choose β as large as needed to make αβ arbitrarily small.
Note that we do not need any hypothesis on the norm (cid:107) · (cid:107) , the result makes only use of the positive homogeneity property.
Consequence On Deep Networks.
Proposition 8 shows that for a deep network trained with l k , one can ﬁx the value of α to 1, and treat the quadratic regularization of the last fully connected layer as an independent hyper-parameter.
By doing this rather than tuning α , the loss keeps the same scale which may make it easier to ﬁnd an appropriate learning rate.
When using the smooth loss, there is no direct equivalent to Proposition 8 because the log-sumexp function is not positively homogeneous.
However one can consider that with a low enough temperature, the above insight can still be used in practice.
D.2. E XPERIMENT ON I MAGE N ET
In this section, we provide experiments to qualitatively assess the importance of the margin by running experiments with a margin of either 0 or 1.
The following results are obtained on our validation set, and do not make use of multiple crops.
Top-1 Error.
As we have mentioned before, the case ( k, τ, α ) =
(1 , 1 , 0) corresponds exactly to
Cross-Entropy. We compare this case against the same loss with a margin of 1: ( k, τ, α ) = We obtain the following results: [Table]
Top-5 Error. We now compare ( k, τ, α ) = (5 , 0 . 1 , 0) and ( k, τ, α ) =
[Table]
D. S UPPLEMENTARY D ETAILS
In the main paper, we report the average of the scores on CIFAR-100 for clarity purposes.
Here, we also detail the standard deviation of the scores for completeness.
[Table]