Title: SMOOTH LOSS FUNCTIONS FOR DEEP TOP-K CLASSIFICATION

Abstract: The top-k error is a common measure of performance in machine learning and computer vision. In practice, top-k classification 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 infinite data. In the context of limited and noisy data however, the use of a loss function that is specifically designed for top-k classification can bring significant 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( n k ) 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 floating 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 overfitting than cross-entropy.

1. INTRODUCTION:

In machine learning many classification 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. Specifically, 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 verified 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-fitting on incomplete or noisy labels.

To alleviate the deficiency of cross-entropy, we present a new family of top-k classification loss functions for deep neural networks. Taking inspiration from multi-class SVMs, our loss creates a Figure 1 : Examples of images with label confusion, from the validation set of ImageNet. The top-left image is incorrectly labeled as "red panda", instead of "giant panda". The bottom-left image is labeled as "strawberry", although the categories "apple", "banana" and "pineapple" would be other valid labels. The center image is labeled as "indigo bunting", which is only valid for the lower bird of the image. The right-most image is labeled as a cocktail shaker, yet could arguably be a part of a music instrument (for example with label "cornet, horn, trumpet, trump"). Such examples motivate the need to predict more than a single label per image.

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 difficulty, 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( n k ). 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 confirm that the difference of performance reduces with large correctly labeled data, which is consistent with known theoretical results.

2. RELATED WORK:

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 classifiers 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. (2017) . 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 classifier to be consistent with regard to the theoretically optimal top-k risk. In other words, cross-entropy satisfies an essential property to perform the optimal top-k classification decision for any k in the limit of infinite 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 fine-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. (2016) 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 difficulty 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.

3. TOP-K SVM:



3.1. BACKGROUND: MULTI-CLASS SVM:

In order to build an intuition about top-k losses, we start with the simple case of k = 1, namely multi-class classification, where the output space is defined 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:

P (s) ∈ argmax s.

(1)

Loss. The classification 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 difficulty, 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 misclassification 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.2. TOP-K CLASSIFICATION:

We now generalize the above framework to top-k classification, 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 (k) in order to distinguish it from a single label ȳ ∈ 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. (2015) , 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.

Difficulty of the Optimization. The surrogate loss l k of equation ( 6) suffers from two disadvantages that make it difficult 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 difficulties to optimizing a piecewise linear loss have also been reported by Li et al. (2017) in the context of multi-label classification. We illustrate this in the next section.

We postulate that the difficulty 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.3. SMOOTH SURROGATE LOSS:

Reformulation. We introduce the following notation: given a label ȳ ∈ Y, Y

(k) ȳ

is the subset of tuples from Y (k) that include ȳ as one of their elements. For ȳ ∈ Y (k) and y ∈ Y, we further define ∆ k (ȳ, y) 1(y / ∈ ȳ). Then, by adding and subtracting the k -1 largest scores of s \y as well as s y , we obtain:

l k (s, y) = max s \y + 1 [k] -s y , 0 , = max ȳ∈Y (k)    ∆ k (ȳ, y) + j∈ȳ s j    -max ȳ∈Y (k) y    j∈ȳ s j    . (7)

We give a more detailed proof of this in Appendix A.1. Since the margin can be rescaled without loss of generality, we rewrite l k as:

EQUATION

)

Smoothing. In the form of equation ( 8), 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 first 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 infinitely 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 classification. 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. 2a , where a large enough value of τ greatly helps the performance on the training set. In Figure 2b , we observe that such high temperatures yield gradients that are not sparse. In other words, with a high temperature, the gradient is informative about a greater number of labels, which helps the training of the model.

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 sufficient and that non-sparsity is a key factor here.

4. COMPUTATIONAL CHALLENGES AND EFFICIENT ALGORITHMS:



4.1. CHALLENGE:

Experimental evidence suggests that it is beneficial to use L k,τ rather than l k to train a neural network. However, at first glance, L k,τ may appear prohibitively expensive to compute. Specifically, there are summations over Y (k)  and Y   (k) y , which have a cardinality of n k and n k-1 respectively. For instance for ImageNet, we have k = 5 and n = 1, 000, which amounts to n k 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 define σ i (e) as the sum of all products of i distinct elements of e. Explicitly, σ i (e) can be written as σ i (e) = 1≤j1<...<ji≤n e j1 ...e ji . The terms σ i are known as the elementary symmetric polynomials. We further define σ 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

= τ log exp(s y /kτ )σ k-1 (exp(s \y /kτ )) + exp (1/τ ) σ k (exp(s \y /kτ ))

-τ log exp(s y /kτ )σ k-1 (exp(s \y /kτ )) .

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 efficiently 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 floating point precision. For the most recent work, see Jiang et al. (2016) . To efficiently train deep neural networks with L k,τ , we need algorithms that are numerically stable with single floating point precision and that exploit GPU parallelization.

In the next sections, we design algorithms that meet these requirements. The final performance is compared to the standard alternative algorithm in Appendix B.3.

4.2. FORWARD COMPUTATION:

We consider the general problem of efficiently computing (σ k-1 , σ k ). Our goal is to compute σ k (e), where e ∈ R n and k n. Since this algorithm will be applied to e = exp(s \y /kτ ) (see equation ( 10)), we can safely assume e i = 0 for all i ∈ 1, n .

The main insight of our approach is the connection of σ i (e) to the polynomial:

EQUATION

Indeed, if we expand P to α 0 + α 1 X + ... + α n X n , Vieta's formula gives the relationship:

EQUATION

Therefore, it suffices to compute the coefficients α 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 coefficients for a degree higher than n -k. However, typically k n. For example, in ImageNet, we have k = 5 and n = 1, 000, therefore we have to compute coefficients up to a degree 995 instead of 1,000, which is a negligible improvement.

To turn k n to our advantage, we notice that σ i (e) = σ n (e)σ n-i (1/e). Moreover, σ n (e) = n 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

Subsequently, in order to compute σ k (e), we only require the k first coefficients of Q, which is very efficient 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 coefficients 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 ← 0 2: P (t) i ← (1, 1/e i ) for i ∈ 1, n

Initialize n polynomials to 

t ← t + 1 8: p ← (p -1)//2

Update number of polynomials 9: end while 10:

P (t+1) ← P (t) × n i=1 e i Recover σ i (e) = σ n-i (1/e)σ n (e)

11: return P (t+1)

Obtaining numerical stability in single floating 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 verified in Appendix B.3.3.

4.3. BACKWARD COMPUTATION:

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 significant 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 efficient 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 ∈ 1, n . 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 definition). 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 (e)) 1≤j≤k , k ∈ N * (σ j (e)) 1≤j≤k have been computed in the forward pass 1: δ 1,i = 1 for i ∈ 1, n 2: for j ∈ 1, k do 3: δ j,i = σ j-1 (e) -e i δ j-1,i for i ∈ 1, n 4: end for 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 inefficiency, we provide a novel approximation in Appendix B.2.2: the computation can be stabilized by an approximation with significantly smaller overhead.

5. EXPERIMENTS:

Theoretical results suggest that Cross-Entropy (CE) is an optimal classifier in the limit of infinite 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 finite 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 classifier. 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 fixed 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.1. CIFAR-100 WITH NOISE:

Data set. In this experiment, we investigate the impact of label noise on CE and L 5,1 . The CIFAR-100 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 "fine" labels. For example, the coarse class "people" is made up of the five fine 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 flips 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 fine label is replaced by a fine 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 = 1 to the case where the label is completely random (within the fine labels of the coarse class). With this method, a perfect top-5 classifier would still be able to achieve 100 % accuracy by systematically predicting the five fine labels of the unperturbed coarse label.

Methods. To evaluate our loss functions, we use the architecture DenseNet 40-40 from Huang et al. (2017) , and we use the same hyper-parameters and learning rate schedule as in Huang et al. (2017) . The temperature parameter is fixed to one. When the level of noise becomes non-negligible, we empirically find that CE suffers from over-fitting and significantly benefits from early stoppingwhich our loss does not need. Therefore we help the baseline and hold out a validation set of 5,000 images, on which we monitor the accuracy across epochs. Then we use the model with the best top-5 validation accuracy and report its performance on the test set. Results are averaged over three runs with different random seeds.

Table 1 : Testing performance on CIFAR-100 with different levels of label noise. With noisy labels, L 5,1 consistently outperforms CE on both top-5 and top-1 accuracies, with improvements increasingly significant with the level of noise. For reference, a model making random predictions would obtain 1% top-1 accuracy and 5% top-5 accuracy. 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 .

Noise:



5.2. IMAGENET:

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 official 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 flip 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 finally 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-18 (He et al., 2016) , adapting the protocol of the ImageNet experiment in Huang et al. (2017) . 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.1 . 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 top-5 validation 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 final 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 ȳ being part of the top-5 prediction should be marginalized over all combinations of 5 labels that include ȳ 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 beneficial to the CE baseline, by up to 1% in the small data setting. 

6. CONCLUSION:

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 fine-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 efficient 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 overfitting 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 specific to top-k classification, and we hope that it will help the design of other surrogate loss functions. In particular, structured prediction problems could benefit from smoothed SVM losses. How to efficiently compute such smooth functions could open interesting research problems.

A SURROGATE LOSSES: PROPERTIES:

In this section, we fix n the number of classes. We let τ > 0 and k ∈ {1, ..., n -1}. All following results are derived with a loss l k defined as in equation ( 8):

EQUATION

A.1 REFORMULATION Proposition 1. We can equivalently re-write l k as:

EQUATION

)

Proof.

EQUATION

A.2 POINT-WISE CONVERGENCE 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 τ →0 τ >0 τ log n i=1 exp(e i /τ ) = 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 τ →0 τ >0

exp((e i -e 1 )/τ ) = 0. Therefore:

lim τ →0 τ >0 n i=1 exp((e i -e 1 )/τ ) = n i=1 lim τ →0 τ >0

exp((e i -e 1 )/τ ) = 1.

And thus:

EQUATION

)

The result follows by noting that:

τ log n i=1 exp(e i /τ ) = e 1 + τ log n i=1

exp((e i -e 1 )/τ ) .

(24)

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 (k) ∆ k (ȳ, y) + 1 k j∈ȳ s j is a strict maximum. Similarly, from s [k-1] > s [k] ,

we have that max

ȳ∈Y (k) y 1 k j∈ȳ s j is a strict maximum.

Since L k,τ can be written as:

EQUATION

the result follows by two applications of Lemma 1.

A.3 BOUND ON NON-SMOOTH FUNCTION:

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 {∆ 1 (ȳ, y) + s ȳ }. 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 1 = α, 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 infinite values simplifies the analysis, and by continuity of L k,τ and l k , the proof will hold for real values sufficiently 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 /τ ) = 0 for i ≥ k + 2, we have:

EQUATION

And:

EQUATION

This allows us to write L k,τ as:

EQUATION

We introduce x = 1 + 1 k (β -α). Then we have:

EQUATION

And:

EQUATION

For any value x > 0, we can find (α, β) ∈ R 2 such that x = 1 + 1 k (β -α) and that all our hypotheses are verified. Consequently, we only have to prove that there exists x > 0 such that:

EQUATION

We show that lim x→∞ ∆(x) < 0, which will conclude the proof by continuity of ∆.

EQUATION

A.4 BOUND ON PREDICTION LOSS Lemma 2. Let (p, q) ∈ N 2 such that p ≤ q -1 and q ≥ 1. Then q p ≤ q q p+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 ∈ 0, k -1 . We introduce the random variable U j , whose probability distribution is uniform over the set U j {ȳ ∈ Y (k) 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 (k) → exp( 1 kτ j∈ȳ s j ). Since P k (s)

is the set of the k largest scores and y / ∈ P k (s), we have that:

EQUATION

)

Therefore we also have that:

EQUATION

)

This finally gives us:

EQUATION

Making the (uniform) probabilities explicit, we obtain:

EQUATION

To derive the set cardinalities, we rewrite U j and V j as:

EQUATION

Therefore we have that:

EQUATION

And:

EQUATION

Therefore:

EQUATION

)

Combining with equation ( 42), we obtain:

EQUATION

obtain approximate δ as follows:

EQUATION

Since e i 1, we quickly obtain unstable results.

Definition 1. For p ∈ {0, ..., n -k}, we define the p-th order approximation to the gradient as:

EQUATION

Proposition 6. If we approximate the gradient by its p-th order approximation as defined in equation ( 60), the absolute error is:

EQUATION

Proof. We remind equation ( 18), which gives a recursive relationship for the gradients:

δ j,i = σ j-1 (e) -e i δ j-1,i .

This can be re-written as:

EQUATION

)

We write σ k+p (e \i ) = δ k+p+1,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+1 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 difficult 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 0.2k). 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 coefficients during the backward. If p 0.2k, this increases the running time of the forward pass by 20%, which is a moderate impact. 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 .

Algorithm 3 Summation Algorithm:

Require: e ∈ R n , k ∈ N * 1: σ 0,i ← 1 for 1 ≤ i ≤ n σ j,i = σ j (e 1 , . . . , e i ) 2: σ j,i ← 0 for i < j Do not define values for i < j (meaningless) 3: σ 1,1 ← e 1 Initialize recursion 4: for i ∈ 2, n do 5:

m ← max{1, i + k -n} 6: M ← min{i, k} 7: for i ∈ m, M do 8: σ j,i ← σ j,i-1 + e i σ j-1,i-1 9:

end for 10: end for 11: return σ k,n

B.3.2 SPEED:

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 3 : Execution time (s) of the forward pass. The Divide and Conquer (DC) algorithm offers nearly logarithmic scaling with n in practice, thanks to its parallelization. In contrast, the runtime of the Summation Algorithm (SA) scales linearly with n. n 100 1,000 10,000 100,000 SA 0.006 0.062 0.627 6.258 DC 0.011 0.018 0.024 0.146

We remind that both algorithms have a time complexity of O(kn). SA provides little parallelization (the parallelizable inner loop is small for k n), which is reflected 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}. 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.3 STABILITY:

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 overflow or underflow is encountered. However this assumption is not verified in our use case, as we demonstrate below. We consider that the algorithm is stable if no overflow occurs in the algorithm (underflows are not an issue for our use cases). We stress out that numerical stability is critical for our machine learning context: if an overflow occurs, the weights of the learning model inevitably diverge to infinite 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) floating point precision.

Table 5 : Stability on forward pass. A setting is considered stable if no overflow has occurred.

τ 10 1 10 0 10 -1 10 -2 10 -3 10 -4 SA (S) SA (D) DC log (S) DC log (D) By operating in the log-space, DC is significantly more stable than SA. In this experimental setting, DC log is stable in single floating point precision until τ = 10 -36 .

C TOP-K PREDICTION: MARGINALIZATION WITH THE ELEMENTARY SYMMETRIC POLYNOMIALS:

We consider the probability of label i being part of the final 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 HYPER-PARAMETERS & EXPERIMENTAL DETAILS D.1 THE TEMPERATURE PARAMETER:

In this section, we discuss the choice of the temperature parameter. Note that such insights are not necessarily confined to a top-k minimization: we believe that these ideas generalize to any loss that is smoothed with a temperature parameter.

D.1.1 OPTIMIZATION AND LEARNING:

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 difficult 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.2 ILLUSTRATION ON CIFAR-100:

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 influence of the temperature: 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 significantly 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 find that setting the temperature to an appropriate fixed value yields the same performance as careful fine-tuning of a pre-trained network with temperature annealing.

D.1.4 PRACTICAL METHODOLOGY:

We summarize the methodology that reflects 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 fixed 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 influenced by the values of k and n (see how these impact the number of summands involved in L k,τ , and therefore its scale). 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 • . 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 ∈ R d × {1, ..., n} N . We (hyper-)parameterize this problem by λ and α:

(P λ,α ) : min

EQUATION

)

Definition 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:

w ∈ R d×n is a solution of (P λ1,α1 ) ⇐⇒ (γw + ν) is a solution of (P λ2,α2 )

Justification. This definition makes sense because for γ > 0, ν ∈ R, (γw + ν) has the same decision boundary as w. In other words, equivalent problems yield equivalent classifiers. Proposition 8. Let λ, α ≥ 0.

1. If α > 0 and λ > 0, then problem (P λ,α ) is equivalent to problems (P αλ,1 ) and (P 1,αλ ).

2. 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 min 

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

:



Figures and Tables:

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): Top-5 training error for different values of τ . The dashed line y = 0.95 represents the base error for random predictions. The successive drops in the curves correspond to the decreases of the learning rate at epochs 150 and 225. -Zero Elements in Derivative (b) Proportion of non (numerically) zero elements in the loss derivatives for different values of τ . These values are obtained with the initial random weights of the neural network, and are averaged over the training set.

Figure2: Influence of the temperature τ on the learning of a DenseNet 40-12 on CIFAR-100. We confirm that smoothing helps the training of a neural network in Figure2a, where a large enough value of τ greatly helps the performance on the training set. In Figure2b, we observe that such high temperatures yield gradients that are not sparse. In other words, with a high temperature, the gradient is informative about a greater number of labels, which helps the training of the model.



Top-5 accuracy (%) on ImageNet using training sets of various sizes. Results are reported on the official validation set, which we use as our test set. The results of Table 2 confirm 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 insignificant amount in the full data setting.

Table content: <table><tr><td colspan="2">% Data Set Number</td><td>CE</td><td>L 5,0.1</td></tr><tr><td/><td>of Images</td><td/></tr><tr><td>100%</td><td>1.23M</td><td colspan="2">90.67 90.61</td></tr><tr><td>50%</td><td>640k</td><td colspan="2">87.57 87.87</td></tr><tr><td>25%</td><td>320k</td><td colspan="2">82.62 83.38</td></tr><tr><td>10%</td><td>128k</td><td colspan="2">71.06 73.10</td></tr><tr><td>5%</td><td>64k</td><td colspan="2">58.31 60.44</td></tr><tr><td>Results.</td><td/><td/></tr></table>

Execution time (s) of the backward pass. Our Custom Backward (CB) is faster than Automatic Differentiation (AD).

Table content: <table><tr><td>n</td><td>100</td><td colspan="2">1,000 10,000 100,000</td></tr><tr><td colspan="3">DC (AD) 0.093 0.139 0.194</td><td>0.287</td></tr><tr><td colspan="3">DC (CB) 0.007 0.006 0.020</td><td>0.171</td></tr></table>

Influence of the temperature parameter on the training accuracy and testing accuracy.

Table content: <table><tr><td colspan="3">Temperature Training Accuracy (%) Testing Accuracy (%)</td></tr><tr><td>0</td><td>10.01</td><td>10.38</td></tr><tr><td>10 -3</td><td>17.40</td><td>18.19</td></tr><tr><td>10 -2</td><td>98.95</td><td>91.35</td></tr><tr><td>10 -1</td><td>99.73</td><td>91.70</td></tr><tr><td>10 0</td><td>99.78</td><td>91.52</td></tr><tr><td>10 1</td><td>99.62</td><td>90.92</td></tr><tr><td>10 2</td><td>99.42</td><td>90.46</td></tr><tr><td colspan="2">D.1.3 TO ANNEAL OR NOT TO ANNEAL</td><td/></tr></table>

Peer review (iclr2018):
 The paper is clear and well written. The proposed approach seems to be of interest and to produce interesting results. As datasets in various domain get more and more precise, the problem of class confusing with very similar classes both present or absent of the training dataset is an important problem, and this paper is a promising contribution to handle those issues better. The paper proposes to use a top-k loss such as what has been explored with SVMs in the past, but with deep models. As the loss is not smooth and has sparse gradients, the paper suggests to use a smoothed version where maximums are replaced by log-sum-exps. I have two main concerns with the presentation. A/ In addition to the main contribution, the paper devotes a significant amount of space to explaining how to compute the smoothed loss. This can be done by evaluating elementary symmetric polynomials at well-chosen values. The paper argues that classical methods for such evaluations (e.g., using the usual recurrence relation or more advanced methods that compensate for numerical errors) are not enough when using single precision floating point arithmetic. The paper also advances that GPU parallelization must be used to be able to efficiently train the network. Those claims are not substantiated, however, and the method proposed by the paper seems to add substantial complexity without really proving that it is useful. The paper proposes a divide-and-conquer approach, where a small amount of parallelization can be achieved within the computation of a single elementary symmetric polynomial value. I am not sure why this is of interest - can*t the loss evaluation already be parallelized trivially over examples in a training/testing minibatch? I believe the paper could justify this approach better by providing a bit more insights as to why it is required. For instance: - What accuracies and train/test times do you get using standard methods for the evaluation of elementary symmetric polynomials? - How do those compare with CE and L_{5, 1} with the proposed method? - Are numerical instabilities making this completely unfeasible? This would be especially interesting to understand if this explodes in practice, or if evaluations are just a slightly inaccurate without much accuracy loss. B/ No mention is made of the object detection problem, although multiple of the motivating examples in Figure 1 consider cases that would fall naturally into the object detection framework. Although top-k classification considers in principle an easier problem (no localization), a discussion, as well as a comparison of top-k classification vs., e.g., discarding localization information out of object detection methods, could be interesting. Additional comments: - Figure 2b: this visualization is confusing. This is presented in the same figure and paragraph as the CIFAR results, but instead uses a single synthetic data point in dimension 5, and k=1. This is not convincing. An actual experiment using full dataset or minibatch gradients on CIFAR and the same k value would be more interesting.