Towards Understanding Why Label Smoothing Degrades Selective Classification and How to Fix It

## Abstract

Abstract Label smoothing (LS) is a popular regularisation method for training neural networks as it is effective in improving test accuracy and is simple to implement. “Hard” one-hot labels are “smoothed” by uniformly distributing probability mass to other classes, reducing overfitting.
Prior work has suggested that in some cases LS can degrade selective classification (SC) – where the aim is to reject misclassifications using a model’s uncertainty. In this work, we first demonstrate empirically across an extended range of large-scale tasks and architectures that LS consistently degrades SC.
We then address a gap in existing knowledge, providing an explanation for this behaviour by analysing logit-level gradients: LS degrades the uncertainty rank ordering of correct vs incorrect predictions by regularising the max logit more when a prediction is likely to be correct, and less when it is likely to be wrong.
This elucidates previously reported experimental results where strong classifiers underperform in SC.
We then demonstrate the empirical effectiveness of post-hoc logit normalisation for recovering lost SC performance caused by LS. Furthermore, linking back to our gradient analysis, we again provide an explanation for why such normalisation is effective.

## 1 Introduction

Label smoothing (LS) (Szegedy et al., ) is a common regularisation technique used to improve classification accuracy in deep learning. The one-hot labels used for cross entropy (CE) are linearly combined with a uniform distribution over classes, redistributing the probability mass and “smoothing” the “hard” targets, discouraging overfitting. Due to its simplicity and empirical effectiveness, label smoothing features in many recent training recipes (Vaswani et al., ; Tan et al., ; He et al., ; Touvron et al., ; Liu et al., ; ; ; Tan & Le, ; ), being particularly popular on the ImageNet-1k (Russakovsky et al., ) image classification benchmark.

Within the domain of uncertainty estimation, LS is well explored in the context of model calibration (Müller et al., ; Chun et al., ; Mukhoti et al., ; Liu et al., ), where the aim is to align a model’s output probabilities with its empirical accuracy. The pairing is intuitive as LS encourages models to output lower probabilities, and models are typically more confident than they are accurate (Guo et al., ). On the other hand, there is very little research investigating the effects of LS in the context of *Selective Classification*.
Selective Classification (SC) (Hendrycks & Gimpel, ; Geifman & El-Yaniv, ; Xia & Bouganis, ; Jaeger et al., ) is a problem setting where, in addition to the primary classification task, a binary rejection decision is made based on the uncertainty estimated by the model, *i.e*. reject/abstain if uncertain. The aim is to reduce the number of failures served by the classifier by pre-emptively rejecting potential misclassifications. It is well motivated by applications where safety and reliability are important due to the high cost of failure. For example, when uncertain, an autonomous driving system may require driver assistance  (Kendall & Gal, ), a medical diagnosis system may defer to a doctor (Beam & Kompa, ; Kurz et al., ), or a visual aid system for the visually impaired may abstain from answering a query (Whitehead et al., ).

Figure: Figure 1: Top: LS causes overconfidence for semantic segmentation. The LS-trained model predicts much lower (ranked) uncertainty on incorrect ✗ segmentations than CE. In particular, for the erroneous region on the left where the model has predicted parts of the “sidewalk” as “road”, the LS model is highly overconfident. This could have dire consequences in a safety-critical application such as autonomous driving. Bottom: LS leads to close to 0% of samples being accepted (coverage) when a strict tolerance of 1% error on accepted samples (risk) is imposed on ImageNet. Deployment-time logit normalisation effectively negates the degradation caused by LS.
Refer to caption: x1.png

Recently Zhu et al. (; ) empirically observe that LS can lead to worse SC for convolutional neural networks (CNNs) performing image classification, yet it is not clear why this occurs.
Concurrently, large-scale empirical evaluations of open-source pre-trained models have shown that many strong classifiers have surprisingly poor SC ability (Galil et al., ; Cattelan & Silva, ). Cattelan & Silva () additionally present deployment-time logit normalisation as a sometimes-effective approach to improving SC, but the reason for its effectiveness remains unclear.
In this work, we aim to empirically validate and analytically demystify the effect of LS on SC, tying together and filling in the gaps in knowledge of previous work with the following key contributions:

- 1.
We show empirically, across a range of large-scale architectures (CNN,ViT) and tasks (image classification, semantic segmentation), that training with LS consistently leads to degraded SC performance (see Fig. 1), even if it may improve accuracy. Moreover, we show that the degradation worsens with stronger LS.
As LS can be found in the training recipes of many of the models evaluated in (Galil et al., ; Cattelan & Silva, ), this suggests LS as one potential cause for previously unexplained negative results where strong classifiers underperform at SC.
- 2.
We address a gap in the understanding of LS by providing an explanation of this behaviour through analysing the logit-level gradients of the LS loss. We show that the amount LS regularises/suppresses the max logit directly corresponds to the true probability of error $P_{\text{error}}$, with regularisation increasing(decreasing) the more likely a prediction is correct(wrong). This leads to relatively higher uncertainty on correct predictions and lower uncertainty on misclassifications, degrading the ranking of uncertainties and hurting SC compared to vanilla CE.
- 3.
We show that post-hoc logit normalisation (Cattelan & Silva, ) is effective in negating the degradation from LS (Fig. 1). Moreover, we elucidate this effectiveness through the lens of our gradient-based analysis. Linking back to the imbalanced logit regularisation of LS, we find that logit normalisation compensates for this effect by increasing uncertainty as the max logit increases.

## 2 Preliminaries

Consider a $K$-class neural network classifier with parameters $\boldsymbol{\theta}$ that models the conditional distribution $P(y|\boldsymbol{x};\boldsymbol{\theta})$ of labels $y\in\mathcal{Y}=\{\omega_{k}\}_{k=1}^{K}$ given inputs $\boldsymbol{x}\in\mathcal{X}=\mathbb{R}^{D}$. Typically the network has a categorical softmax output $\boldsymbol{\pi}(\boldsymbol{x};\boldsymbol{\theta})\in[0,1]^{K}$,

$$ $P(\omega_{k}|\boldsymbol{x};\boldsymbol{\theta})=\pi_{k}(\boldsymbol{x}; \boldsymbol{\theta})=\exp v_{k}(\boldsymbol{x})/\sum\nolimits_{i=1}^{K}\exp v_ {i}(\boldsymbol{x})~{},\quad\boldsymbol{v}=\boldsymbol{W}\boldsymbol{z}+ \boldsymbol{b}~{},$ (1) $$

where $\boldsymbol{v}\in\mathbb{R}^{K}$ are the logits output by the final layer with weight matrix $\boldsymbol{W}\in\mathbb{R}^{K\times L}$, bias $\boldsymbol{b}\in\mathbb{R}^{K}$, and pre-logit features $\boldsymbol{z}\in\mathbb{R}^{L}$ as inputs.
The neural network is trained by minimising the cross entropy (CE) loss on a finite dataset $\mathcal{D}_{\text{tr}}=\{x^{(n)},y^{(n)}\}_{n=1}^{N}$ drawn from distribution $p_{\text{data}}(\boldsymbol{x},y)$, such that it approximately learns the true conditional $P_{\text{data}}(y|\boldsymbol{x})$,

$$ $\displaystyle\mathcal{L}_{\text{CE}}(\boldsymbol{\theta})$ $\displaystyle=-\frac{1}{N}\sum\nolimits_{n}\sum\nolimits_{k}\delta_{y^{(n)} \omega_{k}}\log P(\omega_{k}|\boldsymbol{x}^{(n)};\boldsymbol{\theta})$ (2) $\displaystyle\approx-\mathbb{E}_{p_{\text{data}}(\boldsymbol{x})}\biggl{[}\sum \nolimits_{k}P_{\text{data}}(\omega_{k}|\boldsymbol{x})\log P(\omega_{k}| \boldsymbol{x};\boldsymbol{\theta})\biggr{]}$ (3) $\displaystyle=\mathbb{E}_{p_{\text{data}}(\boldsymbol{x})}\left[\text{KL}\left [\bar{\boldsymbol{\pi}}(\boldsymbol{x})||\boldsymbol{\pi}(\boldsymbol{x}; \boldsymbol{\theta})\right]\right]+\text{const.}~{}=\mathcal{L}_{\text{CE}}^{ \text{true}}(\boldsymbol{\theta})~{},$ (4) $$

where $\delta$ is the Kronecker delta and KL$[\cdot||\cdot]$ is the Kullback–Leibler divergence. We use $\bar{\boldsymbol{\pi}}(\boldsymbol{x})\in[0,1]^{K}$ as a shorthand for the true conditional categorical, *i.e*. $\bar{\pi}_{k}=P_{\text{data}}(\omega_{k}|\boldsymbol{x})$. Predictions $\hat{y}$ are then made on new unlabelled input data $\boldsymbol{x}^{*}$ using classifier function $f$ during deployment,

$$ $\hat{y}=f(\boldsymbol{x}^{*};\boldsymbol{\theta})=\operatorname*{arg\,max} \nolimits_{\omega}P(\omega|\boldsymbol{x}^{*};\boldsymbol{\theta})~{}.$ (5) $$

We also define the probability of the classifier making an error on a given sample as $P_{\text{error}}=1-\bar{\pi}_{\hat{y}}~{}$, where in a slight abuse of notation $\bar{\pi}_{\hat{y}}$ is the true probability of the predicted class $P_{\text{data}}(\hat{y}|\boldsymbol{x})$.

### 2.1 Label smoothing (LS)

Figure: Figure 2: Left: illustration of how label smoothing (LS) alters a training label. LS reduces data supervision and adds regularisation, potentially improving generalisation by reducing overfitting. Right: illustration of selective classification (SC). Uncertain samples ($U>\tau$) are rejected/detected, to reduce the number of errors ✗ served by the system. Rejected samples can be discarded or processed separately (*e.g*. deferred to a human expert). We wish to better separate/rank ✓ vs ✗ via $U$.
Refer to caption: x2.png

Label smoothing involves mixing the original one-hot labels ($\delta$ in Eq. 2) with a uniform categorical distribution $\boldsymbol{u}=1/K\cdot\boldsymbol{1}$ using hyperparameter $\alpha\in[0,1]$ (see Fig. 2). The LS loss is thus

$$ $\displaystyle\mathcal{L}_{\text{LS}}(\boldsymbol{\theta};\alpha)$ $\displaystyle=-\frac{1}{N}\sum\nolimits_{n}\sum\nolimits_{k}\left[(1-\alpha) \delta_{y^{(n)}\omega_{k}}+\alpha\frac{1}{K}\right]\log P(\omega_{k}| \boldsymbol{x}^{(n)};\boldsymbol{\theta})$ (6) $\displaystyle=(1-\alpha)\mathcal{L}_{\text{CE}}(\boldsymbol{\theta})+\alpha \frac{1}{N}\sum\nolimits_{n}\left[\text{KL}\left[\boldsymbol{u}||\boldsymbol{ \pi}(\boldsymbol{x}^{(n)};\boldsymbol{\theta})\right]\right]+\text{const.}~{}$ (7) $\displaystyle\approx\mathbb{E}_{p_{\text{data}}(\boldsymbol{x})}\Bigl{[}\text{ KL}\Bigl{[}\underbrace{(1-\alpha)\bar{\boldsymbol{\pi}}(\boldsymbol{x})}_{ \text{{\color[rgb]{0.58203125,0.41796875,0.9296875}data supervision}}}\,\,+\! \!\!\!\underbrace{\alpha\boldsymbol{u}}_{\text{{\color[rgb]{ 0.61328125,0.5,0.0234375}regularisation}}}\!\!\!\!||\boldsymbol{\pi}( \boldsymbol{x};\boldsymbol{\theta})\Bigr{]}\Bigr{]}+\text{const.}=\mathcal{L}_ {\text{LS}}^{\text{true}}(\boldsymbol{\theta};\alpha)~{},$ (8) $$

where we see that it can also be viewed as reduced
CE supervision from the data combined with a regularisation term encouraging the softmax $\boldsymbol{\pi}$ to be uniform and preventing it from overfitting to the training data (Fig. 2). Eq. 8 also shows that LS can be seen as learning to predict a “softened” version of the true conditional $(1-\alpha)\bar{\boldsymbol{\pi}}(\boldsymbol{x})+\alpha\boldsymbol{u}$, encouraging a model to be less confident on all samples.

### 2.2 Selective classification (SC)

A simple downstream task for estimates of predictive uncertainty is to reject (or detect) predictions that may incur a high cost (Xia & Bouganis, ; Jaeger et al., ), using a binary rejection function,

$$ $g(\boldsymbol{x};\tau)=\begin{cases}0\text{ (reject prediction)},&\text{if }U( \boldsymbol{x})>\tau\text{ (uncertain)}\\ 1\text{ (accept prediction)},&\text{if }U(\boldsymbol{x})\leq\tau\text{ ( confident)}~{},\end{cases}$ (9) $$

where $U(\boldsymbol{x})$ is a scalar measure of predictive uncertainty extracted from the prediction model and $\tau$ is a user-set operating threshold. Intuitively, we reject if the model is uncertain, preventing the system from serving failures, which may then be processed separately. We are only concerned with the relative rankings of $U$s rather than absolute values - we want to be more uncertain on failures.
In the case where the prediction task is classification and we wish to reject potential misclassifications (✗), we can use a selective classifier (Chow, ; El-Yaniv & Wiener, ) $(f,g)$, which is simply the combination of a classifier $f$ (Eq. 5) and the aforementioned binary rejection function $g$ (Eq. 9). Fig. 2 contains an illustration. To evaluate a selective classifier, we use the 0/1 classification error,

$$ $\mathcal{L}_{\text{SC}}(f(\boldsymbol{x}),y)=\begin{cases}0,&\text{if }f( \boldsymbol{x})=y\quad\text{(correct {\color[rgb]{ 0.30859375,0.61328125,0.890625}\char 51})}\\ 1,&\text{if }f(\boldsymbol{x})\neq y\quad\text{(misclassified {\color[rgb]{ 0.890625,0.3984375,0.30859375}\char 55})}~{},\end{cases}$ (10) $$

to define the selective risk (El-Yaniv & Wiener, ; Geifman & El-Yaniv, ) as

$$ $\text{Risk}(f,g;\tau)=\frac{\mathbb{E}_{p_{\text{data}}(\boldsymbol{x},y)}[g( \boldsymbol{x};\tau)\mathcal{L}_{\text{SC}}(f(\boldsymbol{x}),y)]}{\mathbb{E}_ {p_{\text{data}}(\boldsymbol{x},y)}[g(\boldsymbol{x};\tau)]}~{},$ (11) $$

which is the average error on the accepted samples. The denominator of Eq. 11 is the proportion of samples accepted, or the coverage, $\text{Cov}=\mathbb{E}_{p_{\text{data}}(\boldsymbol{x})}[g(\boldsymbol{x};\tau)]$. Our objective is to minimise risk for a given coverage (lower %error on accepted samples) and/or maximise coverage for a given risk (accept more samples). Note this can be achieved both through improving $f$ (fewer errors) and through improving $g$ (better rejection). SC performance is evaluated via the Risk-Coverage (RC) curve (Geifman & El-Yaniv, ) (see Fig. 3 for examples). The area under the curve (AURC$\downarrow$) provides an aggregate metric over $\tau$,(^1^11We note that there are a number of alternative aggregate metrics to AURC (Geifman et al., ; Cattelan & Silva, ; Traub et al., ). We choose to omit them, as we focus on non-aggregated results in this work.) whilst the curve can also be inspected at specific operating points (Whitehead et al., ; Xia & Bouganis, ), *e.g*. coverage at 5% risk (Cov@5$\uparrow$). For deployment, $\tau$ can be set using a held-out validation dataset by finding a suitable operating point on the RC curve according to an external requirement *e.g*. risk$=$1% if tolerance for failure is low.

$$ $U(\boldsymbol{x})=-\text{MSP}(\boldsymbol{x})=-\pi_{\text{max}}=-\max\nolimits _{k}\pi_{k}(\boldsymbol{x};\boldsymbol{\theta})=-P(\hat{y}|\boldsymbol{x}; \boldsymbol{\theta})~{},$ (12) $$

*i.e*. the (negative of the) Maximum Softmax Probability (MSP) (Hendrycks & Gimpel, ) is the model’s estimate of the probability of its prediction $\hat{y}$. We focus on this uncertainty measure $U$ for SC as it is a popular default choice and has been shown to consistently and reliably perform well in the literature (Xia & Bouganis, ; ; Jaeger et al., ; Feng et al., ) compared to alternatives. MSP is a natural choice as $P(y|\boldsymbol{x};\boldsymbol{\theta})$ models $P_{\text{data}}(y|\boldsymbol{x})$, and $U=-\max_{k}P_{\text{data}}(\omega_{k}|\boldsymbol{x})$ (or any scalar monotonic to it) provides the optimal risk if the true distribution $P_{\text{data}}(y|\boldsymbol{x})$ is known (Chow, ).
We omit evaluations on other softmax-based $U$ from the main paper as we find them to behave similarly to MSP. In line with previous work (Xia & Bouganis, ; Jaeger et al., ; Zhu et al., ), we find that OOD detection (Yang et al., ) scores perform poorly at SC, and also omit them (see Sec. E.1 for discussion and additional results).

Over/Underconfidence.
Since we are only concerned about the relative ranking of $U$, we loosely refer to overconfidence as when a model’s estimate of uncertainty for a given sample is (relatively) low when $P_{\text{error}}$ high, as we want a model to be uncertain when it is likely to be wrong. Underconfidence is then the inverse. Both will result in worse SC: overconfidence leads to errors being accepted, underconfidence to correct predictions being rejected.
Intuitively, over/underconfidence may arise from poorness of fit,
where $\boldsymbol{\pi}(\boldsymbol{x};\boldsymbol{\theta})$ fails to accurately model the true conditional distribution $\bar{\boldsymbol{\pi}}(\boldsymbol{x})$ (Fig. 4).

This is different to the definition used in model calibration (Guo et al., ), which, notably, is concerned with marginal
properties (averaged over the input distribution)
rather than per-sample properties, as well as absolute probabilities rather than relative rankings. It is possible to be highly over/underconfident in calibration but optimal for SC and vice versa (Zhu et al., ), *e.g*. applying the monotonic transformation $U=-\max_{k}[P_{\text{data}}(\omega_{k}|\boldsymbol{x})]^{1000}$.
We note that model calibration is an independent task to SC (Jaeger et al., ),
is well explored in the context of LS (Müller et al., ),
and is not the focus of this work. LS may improve calibration by increasing the uncertainty of both correct ✓ and incorrect ✗ predictions, however, this will not necessarily help SC (Zhu et al., ).

## 3 The effect of label smoothing on selective classification

Zhu et al. (; ) observe empirically (as part of a broader investigation) that for a single value of $\alpha$ LS degrades SC for CNN-based image classification. In this section we aim to validate this behaviour on a wider range of large-scale tasks and architectures. We find that LS leads to consistent degradation in SC, with stronger LS leading to greater degradation. We suggest that it may partially explain the findings of recent large-scale empirical evaluations of open-source pre-trained models (Galil et al., ; Cattelan & Silva, ) where strong classifiers surprisingly underperform on SC.

Experimental details.
We investigate large-scale(^2^22We additionally provide $32\times 32$ small-scale CIFAR experiments in Sec. A.3.) image classification on ImageNet-1k (Russakovsky et al., ) and semantic segmentation (pixel-level classification) on Cityscapes (Cordts et al., ). For ImageNet, we evaluate on the original validation set and randomly split 50,000 images from the training set for validation. For Cityscapes, we randomly split the original validation set into 100 validation and 400 evaluation images. To estimate the risk, we extract the model output prior to the final interpolation and subsample 5000 labelled pixels per image at random. We evaluate on the same pixels between models.
The only parameter varied between training runs is the level of LS $\alpha$, and to isolate the effects of LS, we train all models from scratch using simple recipes. We purposely avoid augmentations such as MixUp (Zhang et al., ) and CutMix (Yun et al., ) as these directly affect the training labels, which would interfere with our experiments. For ImageNet classification, we train ResNet-50 (He et al., ) and ViT-S-16 (Dosovitskiy et al., ) using only random resized cropping and flipping for data augmentation. To achieve decent accuracy for ViT training from scratch without advanced augmentations, we use sharpness-aware minimisation (SAM) (Foret et al., ; Chen et al., ). For semantic segmentation on Cityscapes, we train DeepLabV3+ (Chen et al., )
(ResNet-101 backbone) using only random cropping, flipping and colour jitter for augmentations.
Full training details for reproducibility can be found in the Appendix B. We will release our code in the future.

### 3.1 Label smoothing degrades selective classification

Figure: Figure 3: Risk-coverage plots for different levels of LS $\alpha$ for different models and tasks (ImageNet classification and Cityscapes semantic segmentation). Although LS may improve error rate at 100% coverage, increasing $\alpha$ increasingly and consistently degrades SC performance.
Refer to caption: x4.png

To examine the effects of LS on SC, we plot RC curves in Fig. 3. We use $U=-\text{MSP}$ and vary only the LS level $\alpha$ between training runs. We see that training with LS leads to a noticeable degradation for selective classification, with higher $\alpha$ worsening the effect.
We provide illustrative examples of LS overconfidence on ImageNet in Fig. 9. Although LS leads to slightly better risk at higher coverage, it quickly becomes worse than CE as coverage is reduced. The degradation is especially evident for the low-risk regime, which is relevant to safety-critical scenarios where tolerances for error are strict. For example, if the target is to achieve only 1% error/risk on ImageNet, then all of our LS models have close to zero coverage, rendering them effectively useless (Figs. 1 and 3).
To further highlight the overconfidence caused by LS, we visualise the uncertainty ranking of incorrect pixels for the segmentation of a Cityscapes scene in Fig. 1. The LS-trained model is extremely confident for an erroneous region where it has predicted the “sidewalk” as “road”. Whilst the CE model has made the same error, it is much more uncertain. This illustrates potential danger in an autonomous driving scenario if the vehicle is making decisions based on uncertainty estimates.

Upon inspection, many of the SC-underperforming models benchmarked in (Galil et al., ; Cattelan & Silva, ) are trained using LS,
aligning with our results.
The models are sourced from repositories such as torchvision (Paszke et al., ) and timm (Wightman, ), where the training recipes are optimised for top-1 accuracy. We note that for ImageNet, LS is such a common technique that it is often used by default, and not even mentioned in papers, *e.g*. (Tan & Le, ; ).
Overall, our results highlight that only optimising for accuracy may result in negative downstream consequences and that practitioners of SC need to be aware of the effects of their training recipes. We include additional discussion of existing benchmarks and model checkpoints in Sec. E.4.

## 4 Towards explaining the negative effect of LS on SC

In the following section, we attempt to delve deeper into why our empirical results (and those in (Zhu et al., )) occur, shedding light on a previously unexplained phenomenon. It might intuitively seem odd that LS degrades SC performance as the transform applied to the true targets in Eq. 8 $(1-\alpha)\bar{\boldsymbol{\pi}}(\boldsymbol{x})+\alpha\boldsymbol{u}$ reduces the max probability for all samples but does not change the relative ranking. However, this only carries over to the model when it is knowledgeable about the data, so it is well fit $\boldsymbol{\pi}(\boldsymbol{x};\boldsymbol{\theta})\approx(1-\alpha)\bar{
\boldsymbol{\pi}}(\boldsymbol{x})+\alpha\boldsymbol{u}$. For such samples, the model has learnt to be more uncertain. However, we cannot assume that
the model is equally well fit on all regions of the data distribution.(^3^33For the sake of simplicity we avoid the term epistemic uncertainty (see Sec. E.2 for brief discussion).)

Through analysing the logit gradients, we provide a potential explanation: LS suppresses the max logit differently depending on how well fit the model is to a given sample – suppression is stronger(weaker) the more likely a model is correct(wrong), harming the model’s ability to separate ✓ vs ✗.

### 4.1 Comparing logit gradients between CE and LS

To better understand how LS could lead to degraded SC, we consider how LS affects logit-level training gradients. These are the first term in the chain rule for backpropagation and so directly contribute to all parameter gradients during training.
We take the gradient of $\mathcal{L}^{\text{true}}$ (Eqs. 4 and 8),(^4^44Here we assume that the empirical loss $\mathcal{L}$ (Eqs. 2 and 6) approximates $\mathcal{L}^{\text{true}}$, in order to relate our discussion to $P_{\text{error}}$. However, the same analysis on the empirical loss leads to similar conclusions (see Appendix C).)

$$ $\frac{\partial\mathcal{L}_{\text{CE}}^{\text{true}}}{\partial v_{k}}=-\left[ \bar{\pi}_{k}\!\!-\pi_{k}\right],\quad\frac{\partial\mathcal{L}_{\text{LS}}^{ \text{true}}}{\partial v_{k}}=-\biggl{[}\Bigl{[}\,\underbrace{(1-\alpha)\bar{ \pi}_{k}}_{\text{{\color[rgb]{0.58203125,0.41796875,0.9296875}data supervision }}}+\!\!\!\!\underbrace{\alpha/K}_{\text{{\color[rgb]{0.61328125,0.5,0.0234375 }regularisation}}}\!\!\!\!\Bigr{]}\!-\pi_{k}\biggr{]},$ (13) $$

for a single sample, where in a slight abuse of notation
we omit the outer expectation over $p_{\text{data}}(\boldsymbol{x})$ for convenience.
We can then define the regularisation gradient on the logits,

$$ $\frac{\partial\mathcal{L}^{\text{true}}_{\text{reg}}}{\partial v_{k}}=\frac{ \partial(\mathcal{L}_{\text{LS}}^{\text{true}}-\mathcal{L}_{\text{CE}}^{\text{ true}})}{\partial v_{k}}=\frac{\mathcal{L}_{\text{LS}}^{\text{true}}}{\partial v _{k}}-\frac{\mathcal{L}_{\text{CE}}^{\text{true}}}{\partial v_{k}}=\alpha\left [\bar{\pi}_{k}-1/K\right]=\alpha\bar{\pi}_{k}-\alpha/K~{},$ (14) $$

which is the difference between the LS and CE gradients. This represents how LS influences training at the logit level in comparison to CE. Notably, it only depends on the target $\bar{\boldsymbol{\pi}}$. Gradient descent involves updating weights in the opposite direction to the gradient. Hence $\alpha\bar{\pi}_{k}$ suppresses $v_{k}$ when the true probability $\bar{\pi}_{k}$ is higher. The second term $-\alpha/K$ uniformly increases the logits for all samples, which does not affect the softmax as it is invariant to uniform logit shifts $\boldsymbol{\pi}(\boldsymbol{v})=\boldsymbol{\pi}(\boldsymbol{v}+\eta
\boldsymbol{1})$, $\eta\in\mathbb{R}$.

### 4.2 Imbalanced regularisation degrades uncertainty ranking of ✓ vs ✗

Figure: Figure 4: How the regularisation gradient (Eq. 14), which is the difference between LS and CE gradients, affects the logits differently. LS affects the max logit differently depending on how well fit the model is for a given sample $\boldsymbol{x}$. On the left when $U$ is lower (sharper softmax), the regularisation on the max logit is lower when the model is poorly fit and likely to be wrong. On the right when $U$ is higher (flatter softmax), the regularisation is higher when the model is poorly fit and more likely to be correct. Thus, LS degrades the softmax’s ability to separate ✓ vs ✗ , hurting SC.
Refer to caption: x7.png

We now consider how the regularisation gradient affects the maximum logit $v_{\text{max}}$,

$$ $\frac{\partial\mathcal{L}^{\text{true}}_{\text{reg}}}{\partial v_{\text{max}}} =\alpha\bar{\pi}_{\hat{y}}-\alpha/K=\alpha[1-P_{\text{error}}]-\alpha/K,$ (15) $$

which shows that the regularisation on $v_{\text{max}}$ decreases as the probability of error increases. This directly impacts softmax-based $U$ such as MSP (see Eq. 1), especially for lower uncertainties where $v_{\text{max}}$ dominates the softmax. Eq. 15 suggests that for predictions that share the same value of $U$, those with higher $P_{\text{error}}$ (more likely ✗), will have $v_{\text{max}}$ regularised less, whilst predictions with lower $P_{\text{error}}$ (more likely ✓) will have $v_{\text{max}}$ regularised more. Thus, softmax-based $U$ will have the relative ranking of correct ✓ and incorrect ✗ predictions degraded – less uncertain on ✗ , more uncertain on ✓.
To further build an intuition, we consider how a model may not be uniformly well-fit over the data distribution during training. As illustrated in Fig. 4, varying levels of fit with regards to the true distribution $\bar{\pi}$ leads to differing $P_{\text{error}}$ for predictions with similar $U$, resulting in the degradation described above.
Finally, as the regularisation gradient in Eq. 15 is proportional to $\alpha$, this explains why stronger LS leads to greater degradation.
In summary: for a given predicted $U$ the $P_{\text{error}}$ will vary depending on how well fit the model is. LS suppresses the max logit more(less) when $P_{\text{error}}$ is lower(higher), degrading the ranking of ✓ vs ✗ for softmax-based $U$, hurting SC.
We note that although our analysis is performed on training gradients, all our experiments are performed on evaluation data, suggesting that effects indeed generalise to unseen data. We also note that our explanation is purely based on the loss, and thus generalises across network architectures and tasks, matching the empirical results in Sec. 3.

LS empirically leads to higher $v_{\text{max}}$ on misclassifications ✗.
To further validate the effects of Eq. 15, we plot the mean$\pm$std. of $v_{\text{max}}$ given $\pi_{\text{max}}$ for ResNet-50 on evaluation data in Fig. 5. We see that for LS the distribution of correct ✓  is below incorrect ✗, whilst for CE they are roughly similar. This provides further empirical support for Eq. 15 which states that when using LS, $v_{\text{max}}$ is more strongly suppressed for lower $P_{\text{error}}$. For results on other models see Sec. A.2.

LS empirically leads to increasing overconfidence on less-well-fit data.
To further investigate how LS affects uncertainty differently depending on how well-fit/knowledgeable the model is about data, we artificially introduce distribution-shifted data that we expect our models to be worse fit on. We use ImageNet-Sketch (Wang et al., ), a dataset containing sketches of each ImageNet class and evaluate on the combination of the 50,889 ImageNet-Sketch and 50,000 ImageNet evaluation images in Fig. 6.
Even though the regularisation of LS improves the error rate, the degradation of SC at lower coverages from LS is exacerbated by the distribution-shifted data. At 10% coverage of the combined evaluation set, LS leads to accepting many more errors compared to CE, with an increasing proportion originating from ImageNet-Sketch. That is to say, LS leads to increasing overconfidence on less-well-fit data (ImageNet-Sketch). This empirically highlights the situation illustrated on the left of Fig. 4 where confident and well-fit samples have their max logit suppressed, whilst confident but poorly fit samples do not, leading to samples with higher $P_{\text{error}}$ being relatively less uncertain (overconfident).
For results on other models see Sec. A.2.

Figure: Figure 5: Distribution of the max logit $v_{\text{max}}$ given the MSP $\pi_{\text{max}}$ for correct ✓ and incorrect ✗ predictions on evaluation data. $v_{\text{max}}$ is lower for ✓ for the LS model, whilst the distributions are roughly similar for CE. This empirically matches the imbalanced max logit regularisation described in Eq. 15. We calculate the mean$\pm$std. in a 0.05-wide sliding window.
Refer to caption: x8.png

Figure: Figure 6: Left: Evaluation on the combination of ImageNet + ImageNet-sketch. We see that for low-uncertainty predictions, the degradation caused by LS is exacerbated when distribution shift is artificially introduced (vs Fig. 3). Right: statistics @10% coverage of the combined evaluation set. As the level of LS $\alpha$ increases, the number of accepted errors increases, especially from ImageNet-Sketch. This shows that LS leads to increasing overconfidence on less-well-fit data.
Refer to caption: x9.png

## 5 Logit normalisation improves the SC of LS-trained models

Ideally, we would like to find a way to recover from the degradation caused by LS. A recent empirical study by Cattelan & Silva () has shown that logit normalisation can improve the SC performance of many (but not all) pre-trained models. During deployment the logits are normalised by their $p$-norm and then the MSP score $\pi_{\text{max}}$ is replaced by the normalised max logit,

$$ $U=-v^{\prime}_{\text{max}}=-\max\nolimits_{k}v^{\prime}_{k},\quad\boldsymbol{v }^{\prime}=\boldsymbol{v}/\left\lVert\boldsymbol{v}\right\rVert_{p}= \boldsymbol{v}\big{/}\bigl{(}\sum\nolimits_{k}|v_{k}|^{p}\bigr{)}^{\frac{1}{p} }~{},$ (16) $$

where $p$ is found via AURC$\downarrow$ grid search on a validation set.(^5^55Cattelan & Silva () additionally centralise the logits by subtracting the per-sample mean, however, we find this step to be unnecessary for our models so we omit it for simplicity (see Sec. E.5).) We investigate the efficacy of this approach, applying it to our LS-trained models. Figs. 7 and 13 show the SC performance with and without logit normalisation, and we indeed find that applying logit normalisation greatly improves SC performance for models trained using LS, allowing for improved error rate (@100% coverage) with good SC. This is further visualised for semantic segmentation in Fig. 8, where logit normalisation successfully mitigates the overconfidence caused by LS. However, we also find that logit normalisation does not notably improve the SC of CE models. This aligns with (Cattelan & Silva, ) where certain models do not benefit from logit normalisation so the authors suggest “falling back” to the MSP.

Figure: Figure 7: RC curves with inference-time logit normalisation. Logit normalisation improves SC performance on LS models, but has little effect on CE models. For other models, see Sec. A.2.
Refer to caption: x10.png

Figure: Figure 8: Visualisation of the effect of logit normalisation for segmentation (same scene as Fig. 1). Logit normalisation significantly reduces the overconfidence of the LS-trained model, although it has little effect on the uncertainty of the CE-trained model. We provide more figures in Appendix F.
Refer to caption: x11.png

### 5.1 Explaining the effectiveness of logit normalisation.

Although Cattelan & Silva () empirically validate this approach on a large number of pre-trained models, it remains unclear as to why it is so effective, or why it isn’t effective sometimes (further discussion in Sec. E.5). Let us shed light on the interaction between logit normalisation and LS. If we examine Eq. 16, we see that it resembles the softmax, however, the logits are raised to power $p$ rather than exponentiated. Crucially, whilst the softmax is invariant to uniform shifts in the logits,

$$ $\pi_{k}(\boldsymbol{v})=\frac{\exp v_{k}}{\sum_{i}\exp v_{i}}=\frac{\exp(v_{k} +\eta)}{\sum_{i}\exp(v_{i}+\eta)}=\pi_{k}(\boldsymbol{v}+\eta\boldsymbol{1}), \quad\forall\eta\in\mathbb{R}~{},$ (17) $$

this is not the case for $\boldsymbol{v}^{\prime}$. In fact, we have the following inequality for positive(^6^66Although this assumption may not necessarily hold, we find that in practice, $\pi_{\text{max}}$ and $v^{\prime}_{\text{max}}$ are dominated by the larger positive logits, meaning the behaviour discussed still occurs empirically (Secs. E.3 and 20).) logits $\boldsymbol{v}$:

###### Result 1 .

For all
vectors $\boldsymbol{v}\in\left(\mathbb{R}_{>0}\right)^{K}$ with at least two different values and $p\in[1,+\infty[$, the ratio of the $\infty$-norm and $p$-norm strictly decreases when summing $\boldsymbol{v}$ with any uniform vector $\eta\boldsymbol{1}$, $\eta>0$:

$$ $\displaystyle v^{\prime}_{\text{max}}(\boldsymbol{v})=||\boldsymbol{v}||_{ \infty}\big{/}||\boldsymbol{v}||_{p}\quad>\quad||\boldsymbol{v}+\eta \boldsymbol{1}||_{\infty}\big{/}||\boldsymbol{v}+\eta\boldsymbol{1}||_{p}=v^{ \prime}_{\text{max}}(\boldsymbol{v}+\eta\boldsymbol{1})~{}.$ (18) $$

The proof can be found in Appendix D. Recalling that $||\boldsymbol{v}||_{\infty}=v_{\text{max}}$, Result 1 thus implies that for a given softmax output $\boldsymbol{\pi}(\boldsymbol{v})=\boldsymbol{\pi}(\boldsymbol{v}+\eta
\boldsymbol{1})$ and arbitrary corresponding $\boldsymbol{v}$, the greater the value of $\eta$ and thus $v_{\text{max}}$, the lower the value of the normalised max logit $v^{\prime}_{\text{max}}$. That is to say logit normalisation increases uncertainty when the max logit $v_{\text{max}}$ is higher for the same softmax probabilities $\boldsymbol{\pi}$.
Recall how in Sec. 4.2 we show how imbalanced logit regularisation leads to degradation in SC. In particular Fig. 5 shows how LS leads to higher $v_{\text{max}}$ given $\pi_{\text{max}}$ for errors ✗ – this implies that, independent of the value of $\pi_{\text{max}}$, information about $P_{\text{error}}$ has been encoded in $v_{\text{max}}$. We see now that logit normalisation will increase the uncertainty (ranking) of errors ✗  relative to correct predictions ✓  using the information in $v_{\text{max}}$, leading to improved SC for an LS model. That is to say logit normalisation effectively reverses the effect of the imbalanced logit regularisation from LS, improving SC. We note that Cattelan & Silva () find that models that are less confident (on both ✓ and ✗) tend to benefit more from logit normalisation, again pointing towards LS. Given our analysis and empirical results, we strongly recommend logit normalisation for LS-trained models when performing SC. On the other hand, Fig. 5 also shows that the distributions of $v_{\text{max}}$ given $\pi_{\text{max}}$ for correct ✓ and incorrect ✗ predictions are very similar for the CE model. This explains why for CE, logit-normalisation does not seem to help, as $v_{\text{max}}$ does not provide useful information about $P_{\text{error}}$ given $\pi_{\text{max}}$.

###### Result 1 .

## 6 Related work

Prediction with rejection.
Selective classification falls into the broader problem setting of prediction with rejection. In the case of SC, misclassifications are to be rejected (El-Yaniv & Wiener, ). The baseline approach is to use the MSP (Hendrycks & Gimpel, ; Geifman & El-Yaniv, ) and there have been a number of proposed training (Moon et al., ; Huang et al., ; Ziyin et al., ; Zhu et al., ) and architectural (Geifman & El-Yaniv, ; Corbière et al., ) enhancements, however, recently the effectiveness of some of these enhancements has been called into question (Feng et al., ).
Another scenario is out-of-distribution (OOD) detection (Yang et al., ; Hendrycks & Gimpel, ), where data from outside of the training distribution are to be rejected. There is a plethora of research in this field (Xia & Bouganis, ; Sun et al., ; Liu et al., ; Zhang et al., ; Liu et al., ; Wang et al., ; Hendrycks et al., ). Recently, a combination of SC and OOD detection has been proposed, where the aim is to reject both misclassifications and OOD data (Jaeger et al., ; Xia & Bouganis, ; Kim et al., ). Notably, Deep Ensembles (Lakshminarayanan et al., ) have arisen as a reliable method to improve performance in all three scenarios (Kim et al., ; Xia & Bouganis, ; Laurent et al., ; ). We believe, given the results of this work, that extending the investigation of LS (and other training enhancements) to other scenarios involving prediction with rejection is an important avenue of future work.

Mixup.
Mixup (Zhang et al., ) and its variants (Yun et al., ; Franchi et al., ; Pinto et al., ; Liu et al., ; Bouniot et al., ) are a set of regularisation techniques that involve interpolating between random pairs of samples at training time, modifying both inputs and targets. They are commonly found in many ImageNet training recipes (Tan & Le, ; Liu et al., ; ) and are often used in conjunction with label smoothing (Wightman et al., ; Touvron et al., ; Liu et al., ). Research into how Mixup affects SC is a particularly salient avenue of future work as (Zhu et al., ) also observe empirically that it can have a negative impact.

Label smoothing.
Beyond prediction with rejection, LS is well-explored across various contexts. It has been shown to improve model calibration (Müller et al., ; Chun et al., ; Mukhoti et al., ; Liu et al., ) as well as accuracy when training under label noise (Lukasik et al., ). Knowledge distillation (Hinton et al., ), where soft labels are provided by a teacher network, is also commonly linked and combined with LS (Müller et al., ; Gao et al., ; Yuan et al., ; Shen et al., ; Chandrasegaran et al., ) due to their similarity. Interestingly, in a similar vein to our work, pre-training using LS has been shown to harm transfer learning (Kornblith et al., ).

## 7 Concluding remarks

In this work, we elucidate the effect of label smoothing (LS) on selective classification (SC). Our experiments across various tasks and architectures show that LS leads to consistent degradation in a model’s ability to reject misclassifications, even if it improves accuracy. By analysing the logit-level gradients of the LS loss, we provide an explanation for this previously not understood behaviour – LS regularises/suppresses the max logit more(less) the more likely a prediction will be correct(wrong), degrading a model’s uncertainty ranking of correct ✓ vs incorrect ✗ predictions. We then investigate post-hoc logit normalisation as a method to improve the degraded SC performance caused by LS. We find it to be highly effective and shed light on why – it reverses the effect of the aforementioned imbalanced regularisation by increasing the uncertainty when the max logit is higher. We hope that our work encourages more research into understanding how different training techniques may impact model performance in downstream applications such as uncertainty estimation.

## Reproducibility statement

To ensure transparency, we use publicly available datasets: CIFAR-100, ImageNet, and Cityscapes. Our detailed experimental methods are outlined in Appendix B. Finally, the proof supporting our explanation of the effectiveness of logit normalisation is provided in Appendix D.

To help replicate our work, we will soon share our source code on GitHub, including configuration files and the training code. We also plan to release our most important models on Hugging Face.

## Ethics

Our primary objective is to contribute to enhancing the reliability of machine learning methods, with a particular focus on raising awareness about the negative effects of label-smoothing on selective classification. While our work aims to improve the robustness of ML systems, we acknowledge the potential risk that these advancements could be misapplied in harmful ways.

## Table of Contents – Supplementary Material

## Appendix A Additional results

### A.1 Illustrative examples of ImageNet overconfidence

Fig. 9 shows a few examples of overconfident misclassifications on the ImageNet evaluation data by our LS-trained ResNet-50.

Figure: Figure 9: Illustrative examples of overconfident errors performed by our LS-trained ResNet-50 on evaluation data. Even though $P_{\text{error}}$ is high in all cases (*e.g*. due to multiple possible labels), the model predicts low (ranking) uncertainty. Note that even though the CE model is wrong as well, it has assigned higher ranking uncertainties, reflecting its superior SC ability shown in Fig. 3.
Refer to caption: x12.png

### A.2 Complete results for ViT and DeepLabV3+

We include additional experimental results that mirror those found in the main paper on ResNet-50, for ViT-S-16 and DeepLabV3+:

- •
Fig. 10 and Tab. 1 show full ResNet-50 and ViT-S-16 results on ImageNet + ImageNet-Sketch. We see that the behaviour of ViT-S-16 is similar to ResNet-50 (increasing numbers of confident errors from sketch as $\alpha$ increases), but less pronounced.
- •
Figs. 11 and 12 shows the distribution of $v_{\text{max}}$ given $\pi_{\text{max}}$ for ViT-S-16 and DeepLabV3+. We see that similarly to ResNet-50, for LS, the distribution of $v_{\text{max}}$ is higher for errors ✗. Although it is less obvious, it is clear for both ViT-S-16 and DeepLabV3+ that for higher $\pi_{\text{max}}$ the standard deviations overlap much less than for CE.
- •
Fig. 13 shows the effectiveness of logit normalisation for ViT-S-16 on ImageNet and DeepLabV3+ (ResNet-101) on Cityscapes. We also provide 2 additional segmentation figures in Appendix F.

Figure: Figure 10: RC curves when evaluating on the combination of ImageNet and ImageNet-sketch. We see that for low-uncertainty predictions, the degradation caused by LS is exacerbated when distribution shift is artificially introduced. This shows that LS leads to increasing overconfidence on less-well-fit data.
Refer to caption: x16.png

**Table 1: Statistics @10% coverage of the combined evaluation set. As the level of LS $\alpha$ increases, the number of errors increases, especially the number of errors from ImageNet-Sketch.**
| ResNet-50 | @10% coverage of ImageNet + Sketch |  |  |
| --- | --- | --- | --- |
|  | ImageNet | Sketch |  |
| CE | #samples | 8994 | 1094 |
| #errors | 93 | 80 |  |
| error rate | 1.0 | 7.3 |  |
| LS $\alpha=0.1$ | #samples | 8561 | 1527 |
| #errors | 187 | 211 |  |
| error rate | 2.2 | 13.8 |  |
| LS $\alpha=0.2$ | #samples | 8171 | 1917 |
| #errors | 244 | 365 |  |
| error rate | 3.0 | 19.0 |  |
| LS $\alpha=0.3$ | #samples | 7915 | 2173 |
| #errors | 297 | 541 |  |
| error rate | 3.8 | 24.9 |  |

Figure: Figure 11: Distribution of the max logit $v_{\text{max}}$ given MSP $\pi_{\text{max}}$ for correct ✓ and incorrect ✗ predictions separately for ViT-S-16. Similarly to the main paper, the distribution of errors ✗ is higher than correct predictions ✓ for the LS-trained model. We calculate the mean$\pm$std. in a 0.05-wide sliding window.
Refer to caption: x18.png

Figure: Figure 12: The same as Fig. 11 but for DeepLabV3+ (ResNet-101)
Refer to caption: x19.png

Figure: Figure 13: RC curve showing the effect of logit normalisation for ViT-S-16 and DeepLabV3+ (ResNet-101). The behaviour is similar to the results in the main paper. Logit normalisation is effective in improving the performance of the LS-trained models, bringing them close to the CE models. However, logit normalisation makes little difference to the CE-trained model.
Refer to caption: x20.png

### A.3 Small-scale CIFAR experiments

We also include experimental results on small-scale $32\times 32$ CIFAR-100 (Krizhevsky, ). We train a DenseNet-BC (Huang et al., ) ($k=12,L=100$) to show further generality over model architecture families. Figs. 14, 15 and 16 show results that mirror those found in the main paper for ResNet-50 on ImageNet, although we note that LS does not improve top-1 error rate in this case.

Figure: Figure 14: RC curves for DenseNet on CIFAR-100 – LS degrades SC
Refer to caption: x22.png

Figure: Figure 15: DenseNet on CIFAR-100 – logit normalisation improves SC for LS but not for CE
Refer to caption: x23.png

Figure: Figure 16: DenseNet on CIFAR-100 – LS leads to higher $v_{\text{max}}$ on errors ✗
Refer to caption: x24.png

## Appendix B Reproducibility

We recall that *all the code* used in this project will be made available soon to ensure exact reproducibility. We also plan to release our most important models on Hugging Face.

Here, we provide the full details of our training recipes used in the main paper and in the additional results presented in Appendix A. All our models are trained with PyTorch, and we use the native implementation from the CrossEntropyLoss for label smoothing.

### B.1 Image classification

#### DenseNet – CIFAR100.

For the DenseNet trained on CIFAR-100, we extract a subset of CIFAR’s training set containing 5000 images to create a proper validation set. We take batches of 64 32$\times$32-pixel images and train on a single GPU for 300 epochs using stochastic gradient descent and a starting learning rate of 0.1, Nesterov (Nesterov, ; Sutskever et al., ), a momentum of 0.9, and $1\times 10^{-4}$ weight decay. We divide the learning rate by ten after 150 and 225 epochs. We use standard augmentations. We apply random crop with a four-pixel padding as well as random horizontal flip. We do not perform model selection and keep the last checkpoint.

#### ViT-S-16 – ImageNet.

For our ViT-S-16 trained on ImageNet, we take batches of 2048 images and train on 8 V100 for 300 epochs with AdamW (Loshchilov & Hutter, ) with the $\beta$s equal to 0.9 and 0.999. We start with a linear warmup for 15 epochs, then use a cosine annealing scheduler with $3\times 10^{-3}$ as the starting learning rate. The models are trained with non-adaptive sharpness-aware minimisation (SAM) (Foret et al., ; Chen et al., ) with $\rho=0.2$. We use a dropout (Srivastava et al., ) rate of 0.1 but no attention dropout. We transform the training images with a standard random resized crop to 224$\times$224 pixels using bicubic interpolation and a random horizontal flip. For evaluation, we center-crop the images to this resolution. For ImageNet, we do not perform model selection and keep the last checkpoint. However, we randomly extract a validation set of 50000 images from the training set to perform logit normalisation.

#### ResNet-50 – ImageNet.

Our ResNet-50 is trained on 8 V100 with stochastic gradient descent for 120 epochs using a batch size of 1024 images. After five epochs of linear warmup, we use a cosine annealing scheduler starting with a learning rate of 0.4 with a momentum of 0.9 and a weight decay of $1\times 10^{-4}$. We use the same transformation of the images as for the ViT and select the last checkpoint for inference. We use the same validation set as for the ViT for logit normalisation.

### B.2 Semantic segmentation

#### Deeplabv3+.

We train a Deeplabv3+ on CityScapes (Cordts et al., ) with a ResNet-101 (He et al., ) backbone pre-trained on ImageNet (Russakovsky et al., ). We use stochastic gradient descent with a base learning rate of 0.01, divided by 10 for the backbone weights, and reduced following the "poly" policy (Liu et al., ) with a power of 0.9. The weights are optimised with a momentum of 0.9 and a weight decay of $10^{-4}$. We take a batch size of 12 images and train for 40000 steps. During training, we randomly crop the input images and targets to squares with 768-pixel-long sides. We apply random horizontal flip and colour-jitter with the classical parameters: brightness, contrast, and saturation levels of 0.5. For testing, we use the images at their original resolution and do not perform any test time augmentations. For the RC curves, we randomly sample 5000 predictions per image, extracted prior to the final interpolation to reduce correlations between the predictions. We keep the pixel-wise locations of the samples when changing the level of label smoothing $\alpha$ to ensure fair comparisons.

### B.3 Logit Normalisation

We perform logit normalisation as in Eq. 16 directly on the logits $\boldsymbol{v}$. The value of $p$ is searched over $\{1,2,3,4,5,6,7,8\}$ on the corresponding validation data with the optimisation metric as AURC$\downarrow$.

## Appendix C Analysis of empirical loss (one-hot labels)

We can perform a similar analysis as in Sec. 3 using the empirical loss (Eqs. 2 and 6) rather than $\mathcal{L}^{\text{true}}$ as in the main paper. We leave this to the Appendix as the conclusions are similar to analysing $\mathcal{L}^{\text{true}}$, however, the presence of one-hot targets makes it less convenient to reason about the probability of error $P_{\text{error}}$ and how well fit the model is to the true conditional distribution $P_{\text{data}}(y|\boldsymbol{x})$ for a given data sample. Taking the gradients of Eqs. 2 and 6 as in Eq. 13,

$$ $\frac{\partial\mathcal{L}_{\text{CE}}}{\partial v_{k}}=-\left[\delta_{y\omega_ {k}}\!\!-\pi_{k}\right],\quad\frac{\partial\mathcal{L}_{\text{LS}}}{\partial v _{k}}=-\biggl{[}\Bigl{[}\,\underbrace{(1-\alpha)\delta_{y\omega_{k}}}_{\text{{ \color[rgb]{0.58203125,0.41796875,0.9296875}data supervision}}}+\!\!\!\! \underbrace{\alpha/K}_{\text{{\color[rgb]{0.61328125,0.5,0.0234375} regularisation}}}\!\!\!\!\Bigr{]}\!-\pi_{k}\biggr{]},$ (19) $$

which in turn gives the regularisation gradient,

$$ $\frac{\partial\mathcal{L}_{\text{reg}}}{\partial v_{k}}=\frac{\partial( \mathcal{L}_{\text{LS}}-\mathcal{L}_{\text{CE}})}{\partial v_{k}}=\frac{ \mathcal{L}_{\text{LS}}}{\partial v_{k}}-\frac{\mathcal{L}_{\text{CE}}}{ \partial v_{k}}=\alpha\left[\delta_{y\omega_{k}}-1/K\right]~{},$ (20) $$

which is once again independent of the model output $\boldsymbol{\pi}$. In this case, as the label $y$ has already been sampled, the model is either right ✓ or wrong ✗, giving two different regularisation gradients for the max logit $v_{\text{max}}$,

$$ $\frac{\partial\mathcal{L}_{\text{reg}}^{\text{{\color[rgb]{ 0.30859375,0.61328125,0.890625}\char 51}}}}{\partial v_{\text{max}}}=\alpha \left[1-1/K\right]=\alpha-\alpha/K,\quad\frac{\partial\mathcal{L}_{\text{reg}} ^{\text{{\color[rgb]{0.890625,0.3984375,0.30859375}\char 55}}}}{\partial v_{ \text{max}}}=\alpha\left[0-1/K\right]=-\alpha/K~{}.$ (21) $$

We can see that the max logit is more strongly regularised/suppressed during training when the prediction is correct, which aligns with the analysis of $\mathcal{L}^{\text{true}}$ and $P_{\text{error}}$ in the main paper. When the model is correct during training, the max logit is suppressed, but when it is incorrect the max logit is not suppressed. Thus the uncertainty ranking of correct ✓ vs incorrect ✗ data samples is degraded, harming SC. This leads us to the same conclusions as in Sec. 4 and also aligns with the behaviour in Fig. 5 (right) where $v_{\text{max}}$ is higher for errors given the value of MSP.

## Appendix D Result and proof

###### Result .

For all strictly positive vectors $\boldsymbol{v}\in\left(\mathbb{R}_{>0}\right)^{K}$ containing at least two different values and $p\in[1,+\infty[$, the ratio of the infinite norm and the p-norm strictly decreases when summing $v$ and any uniform vector $\eta\boldsymbol{1}$, $\eta$ strictly positive:

$$ $\displaystyle\frac{||\boldsymbol{v}||_{\infty}}{||\boldsymbol{v}||_{p}}>\frac{ ||\boldsymbol{v}+\eta\boldsymbol{1}||_{\infty}}{||\boldsymbol{v}+\eta \boldsymbol{1}||_{p}}.$ (22) $$

###### Proof.

Let there be a real $\eta>0$. Take $p\geq 1$ the dimension of the norm and $\boldsymbol{v}$ a vector of dimension $K\geq 1$ of strictly positive elements $v_{k}$ for $1\leq k\leq K$, such that there exists $1\leq i\leq K$ such that $v_{i}<\max\limits_{k\leq K}v_{k}$. We have that

$$ $\displaystyle 1+\frac{\eta}{v_{k}}\geq 1+\frac{\eta}{\max\limits_{k\leq K}v_{k }},$ (23) $$

and, for at least $i$, we have the same equation, yet with strict inequality.
We can adapt Eq. 23 to get

$$ $\displaystyle v_{k}+\eta\geq\frac{\max\limits_{k\leq K}(v_{k}+\eta)}{\max \limits_{k\leq K}v_{k}}v_{k}.$ (24) $$

And when set to exponent $p\geq 1$, we obtain

$$ $\displaystyle\frac{(v_{k}+\eta)^{p}}{\max\limits_{k\leq K}(v_{k}+\eta)^{p}} \geq\frac{v_{k}^{p}}{\max\limits_{k\leq K}v_{k}^{p}}.$ (25) $$

As for Eq. 23, please note that using $k=i$, we get the same equation as Eq. 25, although with a strict inequality. We can now sum on the elements of $\boldsymbol{v}$ to get

$$ $\displaystyle\frac{\sum\limits_{k=1}^{K}(v_{k}+\eta)^{p}}{\max\limits_{k\leq K }(v_{k}+\eta)^{p}}>\frac{\sum\limits_{k=1}^{n}v_{k}^{p}}{\max\limits_{k\leq K} v_{k}^{p}}.$ (26) $$

By taking the inverse, we get

$$ $\displaystyle\frac{\max\limits_{k\leq K}v_{k}^{p}}{\sum\limits_{k=1}^{n}v_{k}^ {p}}>\frac{\max\limits_{k\leq K}(v_{k}+\eta)^{p}}{\sum\limits_{k=1}^{K}(v_{k}+ \eta)^{p}}.$ (27) $$

And setting the equation to the exponent $p^{-1}$ and replacing the maxima of the $v_{k}$ and $v_{k}+\eta$ with the infinite norm, $||\boldsymbol{v}||_{\infty}$ and $||\boldsymbol{v}+\eta\boldsymbol{1}||_{\infty}$ respectively, we obtain the result.
∎

###### Result .

###### Proof.

## Appendix E Discussions

### E.1 U 𝑈 U italic_U other than MSP

In the main body of the paper we focus solely on MSP as our uncertainty score $U$. Fig. 17 shows how LS affects the SC behaviour of MSP (top) compared two other softmax scores: DOCTOR (Granese et al., ) ($U=-||\boldsymbol{\pi}||_{2}$) (middle) and entropy ($U=H(\boldsymbol{\pi})=-\sum_{k}\pi_{k}\log\pi_{k}$) (bottom). We see that the behaviour is very similar across all three softmax scores, with increasing the level of LS $\alpha$ degrading all the scores. As MSP is the (marginally) best performing and the most commonly used, we thus choose to focus on it for the main paper.

Fig. 18 shows the SC performance of Energy ($U=-\log\sum_{k}\exp v_{k}$) (Liu et al., ), a popular OOD detection score, compared to MSP with and without LS. We see that Energy performs much worse than MSP at SC. This aligns with a large body of existing work (Xia & Bouganis, ; Jaeger et al., ; Kim et al., ; Yang et al., ; Zhu et al., ) that empirically finds that uncertainty scores designed for OOD detection perform poorly at detecting misclassifications and are thus not suitable for SC. Thus we choose not to investigate any OOD detection scores in the main paper. We remark that LS also has a strong negative effect on the SC performance of Energy. This is unsurprising as Energy is dominated by the max logit. An important future direction would be to investigate the effect of LS on various OOD detection scores on the task of OOD detection.

Finally, we also choose to omit various training/architecture-based approaches such as (Ziyin et al., ; Geifman & El-Yaniv, ; Moon et al., ; Zhu et al., ), as we aim to focus our investigation solely on understanding the training effects of LS. We note that LS (potentially combined with post-hoc logit normalisation) is considerably simpler to implement than the aforementioned training-based approaches, and has been shown to be stable in many more use-cases and so may be more likely to be chosen by a practitioner. Besides, recent work (Feng et al., ) has suggested that MSP applied to the methods in (Ziyin et al., ; Geifman & El-Yaniv, ) actually performs better than the $U$s proposed in them (reject logit/selection head).

Figure: Figure 17: The effect of LS on different softmax scores: MSP (top), DOCTOR (middle), Entropy (bottom). We see that the behaviour is very similar, with MSP being the best performer.
Refer to caption: x25.png

Figure: Figure 18: SC performance of MSP and Energy (OOD detection score). Energy significantly underperforms MSP. This behaviour is in line with existing work that shows that uncertainty scores designed for OOD detection are not suitable for SC.
Refer to caption: x28.png

### E.2 Aleatoric and epistemic uncertainty

We recognise that the conceptual decomposition of predictive uncertainty into aleatoric and epistemic uncertainty (Gal, ; Hüllermeier & Waegeman, ; Kirsch, ) can be applied to the discussion throughout this paper, and that some readers may be confused as to why we do not use these terms. We choose to use simpler, more direct language as we believe it more efficiently conveys our discussion, reduces the number of concepts to introduce and also reduces any potential confusion.

### E.3 On the assumption that logits are positive

Figure: Figure 19: Mean$\pm$std after logits have been sorted highest to lowest for ResNet-50 $\alpha=0.2$ on the ImageNet evaluation set. We see that $v^{5}$ and $\exp v$ are much larger for the top $<10$ logits. Thus these logits dominate $\pi_{\text{max}}$ and $v^{\prime}_{\text{max}}$.
Refer to caption: x29.png

Figure: Figure 20: $v^{\prime}_{\text{max}}$ given $v_{\text{max}}$ within bins of similar MSP for ResNet-50 $\alpha=0.2$ on the ImageNet evaluation set. Generally, $v^{\prime}_{\text{max}}$ decreases as $v_{\text{max}}$ increases, showing empirically how logit normalisation increases uncertainty for higher $v_{\text{max}}$. We calculate the mean$\pm$std. of $v^{\prime}_{\text{max}}$ in a 0.2-wide sliding window for samples with $v_{\text{max}}$ within mean$\pm$2std of $v_{\text{max}}$ within the bin (to remove noisy averages).
Refer to caption: x30.png

Result 1 assumes that all elements in the logit vector are $>0$, which is not necessarily true. However, we also find empirically that both $v^{\prime}_{\text{max}}$ and $\pi_{\text{max}}$ tend to be dominated by the largest positive logits. This is intuitive as exponentiating or raising to power $p>1$ will amplify the larger logits. This is shown in Fig. 19, where we plot the mean$\pm$std of $v,v^{5}$ and $\exp v$ for the sorted logits of ResNet-50 $\alpha=0.2$ on the ImageNet evaluation set ($p=5$ is optimal on the validation data for logit normalisation in this case). Thus $\pi_{\text{max}}(\boldsymbol{v})\approx\pi_{\text{max}}(\boldsymbol{v}_{\text{
top-}k})$ and $v^{\prime}_{\text{max}}(\boldsymbol{v})\approx v^{\prime}_{\text{max}}(
\boldsymbol{v}_{\text{top-}k})$, where the top-$k$ logits are positive.
As Result 1 holds for $v^{\prime}_{\text{max}}(\boldsymbol{v}_{\text{top-}k})$, we still expect logit normalisation to increase uncertainty for higher $v_{\text{max}}$ when comparing samples with similar $\pi_{\text{max}}$.

We can also consider the scenario where we add $\eta$ to only the top-$k$ logits. This more aptly describes the empirical logit behaviour compared to adding $\eta$ to all logits, as the values of the lower ranking logits vary much less than the higher ranking ones (Fig. 19). Here we would expect $\pi_{\text{max}}(\boldsymbol{v})$ to increase very slightly, but would expect $v^{\prime}_{\text{max}}(\boldsymbol{v})$ to decrease as the numerator of Eq. 26 would be dominated by the top-$k$ largest logits.

Fig. 20 shows how empirically logit normalisation indeed increases uncertainty for higher $v_{\text{max}}$. We plot the mean$\pm$std of $v^{\prime}_{\text{max}}$ given $v_{\text{max}}$ for samples in different MSP bins. We see clearly that in almost all cases, for samples with similar $\pi_{\text{max}}$, the normalised max logit $v^{\prime}_{\text{max}}$ decreases as the original max logit $v_{\text{max}}$ increases. As shown in Figs. 5, 16, 11 and 12, LS leads to misclassifications ✗ having higher $v_{\text{max}}$ than correct predictions ✓. Thus, logit normalisation is able to improve the SC performance of LS-trained models by penalising the confidence of higher max logit values.

### E.4 Existing benchmarks and training recipes with LS

Although we do not exhaustively search all training recipes for all models benchmarked in (Galil et al., ; Cattelan & Silva, ), we do provide a number of examples of evaluated models trained with label smoothing. We also provide links to publicly available training repositories, as not all papers mention label smoothing even when it is used in training. Upon inspection of (Galil et al., ; Cattelan & Silva, ), these models do in fact seem to underperform at selective classification (and Cattelan & Silva () report that their AURCs benefit from logit normalisation).

- •
EfficientNet (Tan & Le, ): [https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/main.py#L249](https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/main.py#L249)
- •
EfficientNet-V2 (Tan & Le, ): [https://github.com/google/automl/blob/master/efficientnetv2/datasets.py#L658](https://github.com/google/automl/blob/master/efficientnetv2/datasets.py#L658)
- •
DeiT (Touvron et al., ): [https://github.com/facebookresearch/deit/blob/main/main.py#L101](https://github.com/facebookresearch/deit/blob/main/main.py#L101)
- •
Swin-Transformer (+V2) (Liu et al., ; ):
[https://github.com/microsoft/Swin-Transformer/blob/main/config.py#L70](https://github.com/microsoft/Swin-Transformer/blob/main/config.py#L70)
- •
ConvNeXt (Liu et al., ): [https://github.com/facebookresearch/ConvNeXt/blob/main/main.py#L105](https://github.com/facebookresearch/ConvNeXt/blob/main/main.py#L105)
- •
Torchvision (Paszke et al., ) (various): [https://github.com/pytorch/vision/tree/main/references/classification](https://github.com/pytorch/vision/tree/main/references/classification)

Galil et al. () state that some of their best performing (at SC) ViT models (Dosovitskiy et al., ; Steiner et al., ; Chen et al., ) are trained with label smoothing (their Tab.1). However, after inspecting both the original papers and open-source repositories(^7^77[https://github.com/google-research/vision_transformer](https://github.com/google-research/vision_transformer)) of the aforementioned work we were unable to find any confirmation of the use of label smoothing.

### E.5 Logit normalisation in (Cattelan & Silva, 2024 )

#### Explanations of effectiveness.

The work that introduces logit normalisation (Cattelan & Silva, ) is primarily an experimental study, where the focus is on extracting empirical takeaways. However, the authors do discuss potential reasons for the effectiveness of the approach in their Appendix B. They observe that models that are generally (on both ✓ and ✗) more uncertain benefit from logit normalisation and so suggest that logit normalisation alleviates “underconfidence” by reducing the influence of lower-ranked logits on the uncertainty of a prediction (using analysis similar to ours in Appendix D). We believe their explanation is ultimately incomplete as:

- 1.
They do not clearly delineate the definition of over/underconfidence used in model calibration with that used in selective classification. This is an issue since calibration is concerned with absolute marginal (averaged over data samples) properties, whilst selective classification is concerned with relative conditional (per sample) properties. It is possible to be extremely over/underconfident in the calibration sense, whilst being optimal for SC, or very well calibrated and worse at distinguishing correct vs incorrect samples Zhu et al. ().
- 2.
Although they elucidate some of the mechanics of logit normalisation, showing that logit normalisation reduces the impact of smaller logits on uncertainty, they do not link it to any observed model behaviour that differs between correct ✓ vs incorrect ✗ predictions, instead just speculating that models may be underconfident on certain sets of samples. To explain why an approach improves SC, we need to know how it treats ✓ and ✗ differently to improve the rank ordering of uncertainties between ✓ and ✗.

On the other hand, our explanation focuses solely on the relative ranking of uncertainties between ✓ vs ✗ samples and is able to link the mechanics of logit normalisation to how the behaviour of correct ✓ vs incorrect ✗ predictions differ under label smoothing (Figs. 5 and 1).

#### Logit centralisation.

Cattelan & Silva () suggest an additional step of logit centralisation,

$$ $\boldsymbol{v}^{\prime}=\frac{\boldsymbol{v}-\mu(\boldsymbol{v})}{\left\lVert \boldsymbol{v}-\mu(\boldsymbol{v})\right\rVert_{p}},\quad\mu(\boldsymbol{v})= \frac{1}{K}\sum_{k}v_{k},$ (28) $$

which in practice brings most of the lower valued logits close to zero if they are not already. They note that for the majority of models this step is unnecessary, and we also find it unnecessary in our experiments so we omit it for the sake of simplicity. We note that according to the analysis in Sec. 5.1 and Sec. E.3, for logit normalisation to be effective, $v^{\prime}_{\text{max}}$ and $\pi_{\text{max}}$ should be dominated by positive logits, which centralisation seems to empirically ensure by making most of the smallest logits close to zero (Cattelan & Silva, ).

## Appendix F Additional segmentation results

In this section, we complete the picture by providing additional semantic segmentation results to Figures 1 and 8. As in the main paper, the following predictions are performed by a ResNet-101-based DeepLab-v3+ trained on Cityscapes. In these figures, we provide the rank of all the predictions – not only errors – to show the difference between the model’s behavior on its errors but also correct predictions. The rank of the correct predictions ✓ is slightly greyed out compared to the rank of the errors ✗. Figure 21 presents the full ranks corresponding to the scene used in the main paper. We will provide other examples to the readers upon request. Later, we will make our models available to ease the reproducibility of our work.

Figure: Figure 21: We provide all the predicted ranks on our segmentation plots to understand where the model predicted higher relative confidence. The pixel uncertainty rankings provided by the model trained with CE (left) are smoother than those of the model trained with LS $\alpha=0.2$ (right).
Refer to caption: x31.png

Figure 22 shows that the cross-entropy-based model predicts label maps in which pixel uncertainty ranks are smoother than those of the label-smoothing-based one. The label-smoothing model exhibits large areas with low uncertainty rankings, which suddenly decreases nearby the boundary of objects. However, the boundaries are sometimes wrongly predicted, leading to (rank-wise) highly confident errors ✗. The pixels corresponding to the boundaries of objects, where naturally the probability of error is higher and which are most sensitive to label errors, have higher confidence (lower uncertainty ranks) according to the LS-based model than the CE-based model. This explains the high-confidence errors ✗ in the misclassified boundaries of several objects, either in Figs. 1 and 22, and aligns with the imbalanced regularisation of Eq. 15.

We also provide Figure 23 to show that the logit normalisation method is not always successful in solving the ranking of the predictions. In this figure, we see that a large part of the misclassified pixels (lower left) keeps low uncertainty ranks either using the CE-based model or the LS-based model while using logit normalisation. However, there are some improvements on the label-smoothing side, where the original low-ranked boundary errors ✗ are less (rankwise) confident, such as the roof of the car and the right border of the median strip. Interestingly, LS-based high confidence errors in Figure 23 mainly correspond to a change of texture of the median strip – likely associated with an uncertainty on the true label – and correlate with those of the CE-based model. For brevity, we provide an image for a logit normalisation with norm dimension $p=5$, but the results do not differ much from the other values. As stated above, we will provide additional figures to readers upon request.

Figure: Figure 22: Logit normalisation improves on boundary-related very confident errors ✗, but not on the bottom right errors ✗.
Refer to caption: x32.png

Figure: Figure 23: Logit normalisation does not always fix selective classification when used on a model trained with a label-smoothing (right). However, boundary errors ✗ have lower (ranked) confidence, such as for the car’s roof.
Refer to caption: x34.png

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: **Q1:** As observed by the authors, LS consistently leads to degraded SC performance, even if it may improve accuracy. What do authors think about the connection between NLS and SC, where NLS refers to Negative Label Smoothing introduced in R1.

**Q2:** In Line 132, it would be beneficial to include the definition of Kronecker delta.

**References:**

R1: To smooth or not? when label smoothing meets noisy labels. ICML 2022.
soundness: 3
strengths: **Originality**

The paper addresses a unique gap by investigating LS's unintended effect on SC. The logit-level gradient analysis provides a fresh perspective on why LS interferes with SC, helping bridge theoretical understanding with observed results.

**Quality** 

The experiments are well-designed, involving diverse datasets (e.g., ImageNet, Cityscapes) and model architectures (e.g., ResNet-50, ViT) to thoroughly validate the findings. The analysis at both empirical and gradient levels strengthens the rigor, making the results compelling.

**Clarity** 

The paper is well-organized, with clear visuals that illustrate LS’s effect on SC. Figures showing SC degradation and the effects of logit normalization make complex points more accessible.
summary: This paper investigates the impact of label smoothing (LS) on selective classification (SC), showing that while LS is a popular regularization technique for improving classification accuracy, it degrades SC performance. The authors empirically confirm this degradation across various models and tasks, then analyze the cause at a gradient level, finding that LS suppresses the highest logit differently based on prediction correctness. They propose post-hoc logit normalization as a solution, showing it effectively recovers SC performance degraded by LS.
weaknesses: My only concern is about the novelty of the contributions.

**Novelty concern**

* As admitted by the authors (Line 212), some of the core conclusions in the main paper are based on previous empirical observations (```for a single value of alpha LS degrades SC for CNN-based image classification```). And the introduced ```broader investigation``` draws the same conclusion as the literature.

* As specified by the authors (Line 416), another main contribution of the paper (```Logit Nomarlisation Improves the SC of LS-Trained Models```) also follows from the literature that ```logit normalization can improve the SC performance of many (but not all) pretrained models```.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: - The experimental analysis is primarily focused on image classification and segmentation tasks, using two specific datasets. Could these findings generalize to other domains, such as text or tabular data?
- In Figure 3, the degradation impact of LS on SC decreases at high coverage. Is it possible to identify a threshold at which the effect of LS on SC begins to diminish?
soundness: 2
strengths: - The paper provides a well-rounded analysis, both theoretical and experimental, demonstrating how LS degrades SC. By analyzing logit-level gradients, it addresses why LS has this adverse effect on SC, filling an important gap in understanding.
- Visualizations in the paper effectively illustrate the results, providing an intuitive understanding of how LS impacts SC performance.
- The findings have practical impact. By showing that LS leads to consistent degradation in SC, the paper suggests that it may partially explain the findings of strong classifiers surprisingly underperform on SC. They further shows that logit normalization can recover the degradation. This could be useful especially in the high-risk tasks like medical or robotics tasks.
summary: This paper shows how label smoothing (LS) can negatively impact selective classification (SC) by combining empirical analysis on large-scale tasks with theoretical insights on logit-level gradients. The authors show that the degradation in SC performance worsens with increased LS strength, and they propose post-hoc logit normalization as an effective method for recovering SC performance lost due to LS.
weaknesses: The experimental analysis is limited to image classification and segmentation tasks, using only two specific datasets. This raises questions about the generalizability of the findings to other domains, such as text or tabular data, where label smoothing and selective classification may behave differently. Expanding the analysis to include diverse data types would strengthen the claim that label smoothing consistently degrades SC performance across various domains.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: N.A
soundness: 3
strengths: 1. I enjoy reading the paper. The presentation and organization look great.
2. This work provided both empirical and theoretic analysis to answer a research problem and considerably contributed to the field.
summary: This paper explains why logit nomalisation improves SC performance for models trained with label smoothing.
weaknesses: 1. While the authors provided detailed experiments to demonstrate the properties of LS. I think it is also important to quantitatively compare the LS+logit normalisation with other existing solutions under the experimental setting used in this work to demonstrate the effectiveness of such a combination. 

2. In figure 7(a), it is hard to find the "CE logit norm".

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: All my confusions have been listed under the weaknesses section. I welcome the authors to provide clarifications on points 1, 3, and 4.
soundness: 3
strengths: Originality: the paper provides a very detailed and theoretic explanation for the unresolved issue of why label smoothing degrades selective classification.
Quality & Clarity: their explanations appear to be very reasonable. The theoretical gradient descent expressions align with the actual experimental results, making their work seem like a solid theoretical piece rather than some far-fetched guess.
Significance: The authors' explanation addresses a research gap and is likely to be valuable and insightful for future studies in selective classification.
summary: Label smoothing (LS) is a popular regularization technique that improves test accuracy, yet previous research has shown that the LS models achieve degraded performance of selective classification (SC)
By comparing the formulation of Cross Entropy (CE) model and LS model, this work provides an explicit explanation on why this performance degradation is happening.
Building on the identified reasons for this degradation, the authors further discuss the impact of logit normalization and why it significantly improves SC performance of LS models but not that of CE models.
The primary contribution of this paper is the theoretical clarification of a previously unresolved issue. The experimental results are consistent with the theoretical findings presented in the paper.
weaknesses: While the authors present most of the logic and theory in an understandable and clear manner, unfortunately, the confusion in notation and concepts keeps me oscillating between being confused and understanding. The authors probably need to clarify some logic that they consider obvious but which I find uncertain. These points include:

1. Line 318: I would like to know more clearly the connection between the regularization in Equation 13 and the regularization gradient in Equation 14. Because, in my view, regularization refers to -\alpha/K, which is an item in L_LS, but the regularization gradient includes \alpha \bar{\pi}_k - \alpha/K, which is the result of L_LS - L_CE. The relationship between these two needs to be explicitly identified when they have similar names.
2. Line 319: There is a typo after the second equals sign in the formula.
3. Line 353: 'This directly impacts softmax-based U such as MSP', but I am not very clear on how. In fact, starting from Part 4.2, I completely lost track of the concepts of uncertainty, various expressions of pi, regularization, and P_error. This makes me feel like I understand but I don't.
4. Line 371: Again, due to the confusion on the concepts, 'v_max is more strongly suppressed for lower P_error' is not intuitive to me.
5. The caption for Figure 4 is confusing. Which one is the left, and which one is the right?
6. The caption for Figure 5 is confusing. What is the purpose of Figure 3? What does it illustrate? It is not clear.

Meta-review: The paper studies the effect of label smoothing (LS) on selective classification (SC) performance. Empirically, it is shown that LS systematically degrades the performance of the maximum softmax probability SC baseline. Analytically, it is shown that the reason for this can be traced to the gradient updates under LS favouring a stronger pull for samples with a lower inherent noise rate. This analysis is then extended to elucidate why logit normalisation can fare significantly better.

Reviewers were unanimously supportive of the paper. The work was found to be well-presented, intuitive, and of broad interest to practitioners. From the AC's reading, we tend to agree with this assessment.

Some critiques raised were that the work is limited to a few image classification datasets, and is as such more concerned on an analysis of known techniques (rather than proposing a new technique). For the latter, we tend to agree with the authors that such works are appropriate for ICLR, and should be of interest to the community. For the former, we agree that additional results for the empirical section (which is intended to be comprehensive) would be useful. The authors have added some results for tabular datasets which are a step towards this.

Overall, we believe this work is of interest to the community, and recommend its publication.

_Minor remark_: Appendix F.6 has some interesting analysis of "negative label smoothing". This appears related to the "backward correction" technique discussed in Lukasik et al., "Does label smoothing mitigate label noise?", ICML 2020.

Decision: Accept (Poster)