Enhancing Robustness of Last Layer Two-Stage Fair Model Corrections

Authors: nathan  stromberg
rohan  ayyagari
sanmi  koyejo
richard  nock
lalitha  sankar
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-15 20:02:23

Abstract: Last-layer retraining methods have emerged as an efficient framework for correcting existing base models. Within this framework, several methods have been proposed to deal with correcting models for subgroup fairness with and without group membership information. Importantly, prior work has demonstrated that many methods are susceptible to noisy labels. To this end, we propose a drop-in correction for label noise in last-layer retraining, and demonstrate that it achieves state-of-the-art worst-group accuracy for a broad range of symmetric label noise and across a wide variety of datasets exhibiting spurious correlations. Our proposed approach uses label spreading on a latent nearest neighbors graph and has minimal computational overhead compared to existing methods.

Main paper: 
 introduction: 
 In order to ensure fairness between subpopulations, an important metric to consider is the lowest accuracy amongst all subpopulations, often referred to as worst-group accuracy (WGA). State-of-theart methods for optimizing WGA utilize group membership information to modify the training loss [1, 12, 21, 20, 22] or the distribution of the training data [10, 6, 11] in order to account for imbalance amongst groups and successfully train a classifier which is fair across groups.While these methods can achieve astounding WGA, many have significant computational and data costs. Last-layer retraining (LLR) has emerged as a popular method to adapt existing deep models with minimal overhead while ensuring fairness [10, 11, 22, 20] . Additionally, the necessity of group membership information has been relaxed as new methods infer group membership by utilizing auxiliary classifiers to detect minority groups (generally known as two-stage methods) [11, 6, 12, 16, 22] . Taken together, it is now possible to correct powerful deep models for worst-group accuracy with low computational and data cost. Two methods using this approach are SELF [11] and RAD [22] .Unfortunately, class labels are often noisy [25] in practice. Further, Oh et al. [16] demonstrated just how fragile most two-stage model corrections are in the face of this issue. While Oh et al. [16] presented a method with improved robustness to label noise, their method requires fully retraining the base model and cannot match the performance of existing methods at low noise levels. To address these issues, we connect the existing literature on label propagation and worst-group accuracy correction, i.e., we utilize label spreading on the latent nearest neighbors graph to correct for noisy labels and two-stage LLR methods to maximize WGA without domain annotations. We list our main contributions below.• We highlight the failure of state-of-the-art (SOTA) LLR methods, in particular, SELF [11] and RAD [22] , under target label noise.• We introduce an elegant label correction preprocessing method that significantly improves the performance of the SOTA LLR methods under label noise. The key insight here is that LLR models operate on largely separable embeddings, and therefore, label noise can be potentially corrected using label propagation techniques.• For various spurious correlation datasets, we highlight the effectiveness of our modular approach when combined with both SELF and RAD and compare it to domain-aware and full retraining methods.Subgroup Robustness Downsampling has become one of the most common methods of increasing WGA. Kirichenko et al. [10] propose deep feature reweighting (DFR), which downsamples majority groups to the size of the smallest group to rebalance the retraining set. Chaudhuri et al. [4] explore the effects of downsampling theoretically and show that downsampling can increase WGA under certain data distribution assumptions. LaBonte et al. [11] propose using class-balancing when group membership information is unavailable and demonstrate its efficacy.Upweighting is a popular alternative to downsampling as it utilizes all available data. Idrissi et al. [7] show that upweighting relative to the proportion of groups can achieve strong WGA, and Welfert et al. [26] prove downsampling and this form of upweighting are statistically equivalent. Upweighting has been extended to domain annotation-free settings by Qiu et al. [20] through loss-weighted learning.Domain annotation-free methods often use a secondary model to identify minority groups. These are referred to as two-stage methods. Qiu et al. [20] use the pretrained model itself but do not explicitly identify minority examples and instead upweight proportionally to the loss. Unfortunately, this ties their identification method to the choice of the loss. Liu et al. [12] consider fully retraining the pretrained model as opposed to only the last layer, but their method of minority identification using an early stopped model is considered in the last layer in LaBonte et al. [11] . LaBonte et al. [11] not only consider early stopping as implicit regularization for their identification model, but also dropout (randomly dropping weights during training). Stromberg et al. [22] consider an explicit ℓ 1 regularizer, building on the work of LaBonte et al. [11] and Kirichenko et al. [10] .Wei et al. [25] show that human annotation of image class labels can be noisy with up to a 40% noise proportion, thus motivating the need for robust methods for WGA. Oh et al. [16] consider robustness to class label noise. Their method, END, utilizes predictive uncertainty from a robust identification model to select an unbiased retraining set. Their method struggles against SOTA methods at low noise levels and is not easily adapted to other error set-selection techniques. Still, it achieves strong performance in the high noise regime where other two-stage full retraining methods fall apart.The problem of spreading labels from a small, but well-annotated set of reference points to a larger unlabeled set has been extensively explored in the literature. For a survey of basic methods of label propagation on a graph, see Bengio et al. [2] and references therein. The graph on which labels are propagated is critical to the success of these methods. Common graphs are the k-nearest neighbors (kNN) graph, the adjacency matrix of an undirected graph, or an underlying directed acyclic graph (DAG).When labels are noisy, the objective of label propagation may be ill-equipped to correct these labels, but the general principles can be of use. For a restricted classifier setting, Gao et al. [5] prove the robustness of the kNN learning procedure to label noise and give a sense of how to choose k, the number of nearest neighbors, via an excess risk bound. This inspires our empirical analysis and our results verify the trends suggested by their bound. Iscen et al. [9] utilize neighbor consistency to deal with noisy labels when training deep models and frame their method as an implicit label propagation. Patrini et al. [19] consider label noise and possible corrections via loss and logit reweighting.Label propagation and spreading have also been used in the semi-supervised learning setting for both general models and those focused on subgroup fairness. Iscen et al. [8] include label propagation in order to learn general deep models in a semi-supervised manner. Nam et al. [15] utilize an auxiliary model inspired by the label propagation objective to predict group labels on unlabeled samples. This allows for semi-supervised fair training. Unfortunately, their method is very costly as it involves training both a spurious attribute prediction model and running GroupDRO [21] .Our work combines the ideas of two-stage last-layer corrections of LaBonte et al. [11] , Stromberg et al. [22] with simple label propagation techniques in the latent space of the original (unfair) model. Because we have a low-dimensional embedding in which clean examples are well-separated by a linear classifier, we can utilize kNN label spreading with many nearest neighbors, which is enough to correct most label noise in the training data. With this preprocessing method, we can then proceed with any two-stage last-layer WGA correction to achieve fairness without domain information. Thus, our method is an elegant plug-and-play addition to last-layer subgroup robustness methods, which achieves SOTA test WGA when training with noisy class labels. 
problem setup: 
 LetD = {(X i , Y i )} n i=1 be a dataset of n iid examples with features X i ∈ X and class label Y i ∈ Y. Additionally let G = {G i } ki=1 be a partition of D, that is each G i ⊆ D, corresponding to the k groups of interest. In general, this partition is unknown at training time.We are given a pre-trained deep modelEQUATIONwhere Φ : X → R d is an embedding function and σ : R → [0, 1] |Y| such that σ y is the estimate of the probability that X is in class y. An example of σ is the oft-used softmax function. We assume that f is trained on clean data. While this may seem like a strong assumption, it can be relaxed as recent work suggests that feature embeddings are typically robust to label noise [9, 17] .We seek to retrain solely the last layer of f in order to increase the worst-group accuracy of the model. That is we learn a θ WGA such thatEQUATIONThat is, θ WGA maximizes the worst-group accuracy (WGA). We will use WGA as our metric for all of our discussions moving forward.We assume that we observe not D, but D = {(X i , Ỹi )} n i=1 where Y has been affected by symmetric label noise with noise level p ∈ (0, 1/2). In general, this noise could be caused by human error, data corruption, or malevolence. Patrini et al. [19] consider a wider class of class-dependent noises and show that in general, predictors can be made robust to such noise with relatively simple adjustments to the loss function or data distributions. This simple correction is not helpful in two-stage methods as demonstrated by Oh et al. [16] ; we expand on this further in Section 2.3.When we have information about the group membership G, standard methods are to upweight examples proportional to their group size or to remove samples from larger groups. Specifically, group upweighting (GUW) seeks to minimize the following objective:EQUATIONwhere the inner sum is upweighted by a factor inversely proportional to its prevalence in the dataset. Group downsampling (GDS) takes a similar approach, but sub-samples all groups which are larger than the smallest group. Denoting n min = min Gi∈G |G i | as the size of the smallest group, we can write the GDS objective as:EQUATIONwhere G i is a downsampled version of G i with size n min .These two approaches are examined theoretically in Chaudhuri et al. [4] , Welfert et al. [26] , though their performance in the presence of label noise is unclear. Patrini et al. [19] suggest that a related upweighting factor to Equation (3) may be helpful in combating label noise (the so-called backwards correction) suggesting that GUW may be robust to label noise. Welfert et al. [26] prove that GUW and GDS are equivalent in the statistical setting (infinitely many samples), which suggests that GDS should also have some resilience to label noise. We explore this empirically in Section 4.When group membership information is unavailable, techniques that build on GUW or GDS have been explored. Broadly they fall into the category of two-stage corrections [6, 12, 16, 14] , and more specifically in our setting, last-layer model corrections for worst-group accuracy [11, 22] . These methods make the assumption that the groups of interest are determined by a tuple of class label Y and domain label D. Additionally there is a spurious correlation between Y and D which causes the base model f to perform poorly on minority groups. This same correlation is exploited when correcting the model in that an error set, E, is constructed that is likely to contain minority examples:EQUATIONwhere f bias is the base model f for LaBonte et al. [11] and a highly regularized model intended to increase performance in Stromberg et al. [22] . This error set is then used as a proxy for a groupbalanced or minority-dominated subset, respectively, for fair retraining. We present a simplified version of the RAD [22] and SELF [11] algorithms in Algorithm 1 and Algorithm 2 respectively. Note that in this work we focus on the misclassification version of SELF, but other variations are discussed by LaBonte et al. [11] . The intuition behind these methods is that the error set will likely contain mostly minority examples as the majority should be easily captured by the biased classifier.The construction of this error set is precisely why using a noise-robust loss [16] or a corrected loss [19] is not enough to achieve robustness to label noise for two-stage LLR methods. The robust models will still (correctly) misclassify noisy examples, including them in the error set for retraining (see Appendix C for experimental results in this setting). This results in an error set which is dominated by noisy majority points rather than clean minority points. This is exacerbated by SELF which keeps only the examples with highest loss (most likely to be noisy). We present a proof of this failure for RAD in a group-conditional Gaussian setting in Appendix B Proposition 2. Oh et al. [16] circumvent this problem by changing the construction of the error set to depend on the entropy of the predictions rather than their correctness. While this increases robustness to label noise, it comes at the cost of clean performance. We instead focus on cleaning the labels so that we can realize the performance gains of existing two-stage methods.Algorithm 1 RAD [22] Algorithm Input: D = (x i , y i ) for i ∈ [n], c: penalty factor, λ: upweight factor E ← ∅ Learn θ bias minimizing (x,y)∈D ℓ(x, y; θ) + c∥θ∥ 1 (6) ŷ y y ← f (x x x; θ bias ) if ŷi ̸ = y i then E ← E ∪ (x i , y i ) end if Learn θ RAD minimizing (x,y)∈D\E ℓ(x, y; θ) + λ (x,y)∈E ℓ(x, y; θ) (7) Return: θ RAD Algorithm 2 SELF [11] Algorithm Input: D = (x i , y i ) for i ∈ [n], n sub : size of reweighting set E ← ∅ ŷ y y ← f (x x x; θ) if ŷi ̸ = y i then E ← E ∪ (x i , y i ) end if Subsample E to selectReturn: θ SELFQuestion: Does the paper discuss the limitations of the work performed by the authors?Answer: [Yes]Justification: We point out that we use clean embeddings and have a clean holdout dataset, which is common in the literature. We additionally provide references that suggest clean embeddings may not be necessary.Guidelines:• The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper. • The authors are encouraged to create a separate "Limitations" section in their paper.• The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be. • The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated. • The authors should reflect on the factors that influence the performance of the approach.For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon. • The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size. • If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness. • While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations. 
label spreading for robust worst-group accuracy: 
 To correct for label noise in the training data, we will consider the labels of each point's nearest neighbors. We denote the k nearest neighbors matrix as V k where V k (i, j) is 1 if X j is one of the k nearest neighbors of X i in ℓ 2 distance and 0 otherwise. Thus 1 k V k is a row-stochastic matrix with a uniform distribution on each point's k nearest neighbors. Note that V k is not necessarily symmetric and so defines a directed graph.We update the estimated labels iteratively by taking a uniformly-weighted majority vote of each point's nearest neighbors. The idea is that noise is added at random to each class, thus it is likely that for noise level p, 1 -p proportion of a given query point's neighbors have clean labels. It is intuitive to select a higher k for increasing p in order to minimize the effect of local noise density. Thus most noisy points will be corrected after just one round of spreading, and noise will continue to diminish unless there is a small cluster which is especially noisy. See Gao et al. [5] for a more complete theoretical treatment of kNN classification with label noise.To better understand how the choice of k is affected by the noise parameter p consider the following: Proposition 1 (Theorem 2 from Gao et al. [5] ). For k ≥ 8 and symmetric label noise level pEQUATIONwhere R * is the Bayes optimal risk, R k is the risk of kNN, d is the data feature dimensions, and L is the Lipschitz constant of the Bayes optimal classifier.For d ≫ 1, minimizing the upper bound in Equation ( 9) leads to the dependence of k on p asEQUATIONcorroborating the intuitive choice of larger k for larger amounts of noise.Because of the effectiveness of simple domain-aware LLR methods like GDS and GUW, it may be tempting to consider kNN label spreading for domain noise as well as target noise. In this way, we could correct for the failures of GUW and GDS seen by Stromberg et al. [22] which lead them to propose RAD. The effectiveness of kNN label spreading for target labels is mainly due to the fact that the clean embeddings are close to linearly separable (that is the original base model had high accuracy). In practice, not only are classes linearly separable in the latent space, but are tightly clustered. This has been observed empirically and partially explained theoretically under the framework of neural collapse [18] . Such collapse has not been seen for subgroups when this information is not explicitly utilized in the training of the base model. Thus it is unreasonable to expect that domains should be as well separated as classes. This limits the effectiveness of kNN label spreading for domain labels, but as we demonstrate in Section 4, kNN-RAD can achieve SOTA WGA without using domain labels at all in the training phase. Nam et al. [15] bypass this issue by training a separate neural network to predict group membership using semi-supervised data, effectively causing neural collapse for groups rather than classes. However, their method suffers from poor computational performance and struggles to deal with label noise as demonstrated by Oh et al. [16] .In order to retrain the base model, we first perform T rounds of kNN label spreading (in practice we take T = 1) and then pass the cleaned labels to any last layer method. We denote the combination of these procedures kNN-RAD, Algorithm 3, or kNN-SELF, Algorithm 4, depending on the two-stage method used after label spreading. While we focus on using embeddings from a model trained on clean data, prior work suggests that the embeddings should be relatively robust to label noise [9, 17] .Algorithm 3 kNN-RAD Algorithm Input: D = (x i , ỹi ) for i ∈ [n], k: number of neighbors, c: penalty factor, λ: upweight factor Calculate kNN graph V k ŷ y y (0) ← ỹ y y for t = 1, . . . , T do ŷ y y (t) ← 1(V k ŷ y y (t-1) ≥ k 2 ) end for θ RAD ← RAD(x x x, ŷ y y (T ) , c, λ) (Algorithm 1) Return: θ RAD Algorithm 4 kNN-SELF Algorithm Input: D = (x i , ỹi ) for i ∈ [n], k: number of neighbors, n sub size of reweighting set Calculate kNN graph V k ŷ y y (0) ← ỹ y y for t = 1, . . . , T do ŷ y y (t) ← 1(V k ŷ y y (t-1) ≥ k 2 ) end for θ SELF ← SELF(x x x, ŷ y y (T ) , n sub ) (Algorithm 2) Return: θ SELFQuestion: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?Answer: [NA] Justification: No theoretical results are presented Guidelines:• The answer NA means that the paper does not include theoretical results.• All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced. • All assumptions should be clearly stated or referenced in the statement of any theorems.• The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition. • Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material. • Theorems and Lemmas that the proof relies upon should be properly referenced. 
experiments: 
 We present worst-group accuracies for several representative methods across four large publicly available datasets. Specifically, we compare kNN-RAD and kNN-SELF to END [16] which aims to provide robustness to label noise for two-stage full retraining methods. As baselines we include group upweighting (GUW) and group downsampling (GDS) which are simple and effective, but require domain annotations which are not available to other methods. Additionally, we demonstrate that uncorrected RAD [22] and SELF [11] suffer large performance degradation under label noise.We perform our experiments with several common datasets in the literature of worst-group accuracy, including three vision datasets and one text dataset. Following prior work [10, 11] , we use half of the validation as retraining data (with noisy target labels) and half as a clean holdout. More details can be found in Appendix A.CMNIST [1] is a variant of the MNIST handwritten digit dataset in which digits 0-4 are labeled y = 0 and digits 5-9 are labeled y = 1. Further, 90% of digits labeled y = 0 are colored green and 10% are colored red. The reverse is true for those labeled y = 1. Thus, we can view color as a domain, and we can see that the color of the digit and its label are correlated.CelebA [13] is a dataset of celebrity faces. For this data, we predict hair color as either blonde (y = 1) or non-blonde (y = 0) and use gender, either male (d = 1) or female (d = 0), as the domain label. There is a correlation in the dataset between hair color and gender because of the prevalence of blonde female celebrities.Waterbirds [21] is a semi-synthetic dataset which places images of land birds (y = 1) or sea birds (y = 0) on land (d = 1) or sea (d = 0) backgrounds. There is a correlation between background and the type of bird in the training data but this correlation is removed in the validation data.CivilComments [3] is a text corpus dataset of public comments on news websites. Comments are labeled either as toxic (y = 1) or civil (y = 0) and the spurious attribute is the presence (d = 1) or absence (d = 0) of a minority identifier (e.g. LGBTQ, race, gender). There is a strong class imbalance (most comments are civil), though the domain imbalance is modest.To empirically evaluate the effectiveness of kNN label spreading, we add symmetric label noise to embeddings from three image datasets and then perform label spreading over 10 rounds. We see in Figure 1 that kNN label spreading can correct most of the noise present in the training data with only one round of spreading. This is likely due to the well-separated nature of the embeddings. CMNIST suffers from decreasing performance with too many rounds or neighbors as the data is not perfectly clustered into classes as it is in the other image datasets. Here, it is likely that the nearest neighbors for the small clusters to the side in Figure 2 are of the opposite class, allowing noisy points to spread more easily than clean points. For this reason, we employ a smaller value of k for CMNIST than for other datasets. Distance-weighted voting could be another way to combat this issue. Additionally, because the label spreading process is so quick, we spread for only 1 round in practice. A distance-weighted approach may require more rounds for clean labels to spread throughout the dataset.While we assume that the embedding model Φ is train on clean (but imbalanced) data, it is not always the case in practice. While Iscen et al. [9] suggest that embeddings are relatively robust to noise, they find that the classification head is not. Both RAD and SELF rely on the embeddings and SELF on the classification head as well. Additionally, the kNN label spreading proposed in this work assumes clean embeddings with only symmetric label noise.To explore how robust our method is to violation of these assumptions, we train base models for both CelebA and Waterbirds on data which contained 20% SLN. We then test the finetuning procedure with varying levels of label noise. We see in Table 1 that both RAD and SELF suffer when using noisy embeddings, and this is only exacerbated by noise in the finetuning set. Still, kNN label cleaning is able to provide a significant boost in performance despite having relatively low-quality embeddings. We see a similar trend for Waterbirds in Table 2 which shows even stronger performance gains for kNN over vanilla two-stage methods.It is also notable that SELF has significantly worse performance than RAD when using noisy embeddings, likely because SELF additionally reuses the final classification layer of the base model.Previous work [8] has shown that most of the drop in performance when training deep models with noisy data comes from a poor classification head.We report the worst-group accuracy of each approach and its standard deviation over 10 noise seeds. Note that for END [16] , we report the results of Oh et al. [16] . For SELF [11] and RAD [22] , we implement their algorithms ourselves to ensure a fair comparison. Each table involves the following: • We write GUW * and GDS * to denote the worst-group accuracies of upweighting and downsampling, respectively, that can be achieved with oracle access to clean domain labels at training time. Note that such access is not available to the two-stage methods.• We highlight in bold both the best domain annotation-free method for each noise level and the method within one standard deviation of the best.• The "Domain Annotation" column denotes whether a method requires access to domain annotation only at validation (model selection) time or over both training and validation phases. The "Layer" column denotes whether a given method retrains only the last layer or the full model.For the CMNIST dataset, in Table 3 we see that kNN label spreading gives small gains over vanilla RAD, but even vanilla RAD is not significantly diminishing in performance with increasing noise levels. This is likely due to the ease of the dataset overall. As noted in Section 3, CMNIST is not as strongly clustered as other image datasets, so it is necessary to use a smaller number of nearest neighbors. Here, kNN-SELF provides small gains over vanilla SELF as both are fairly robust.For the CelebA dataset, Table 4 shows that kNN-RAD achieves dramatically improved performance relative to vanilla RAD and also over END. Although it retrains only the last layer, kNN-RAD achieves SOTA performance for domain annotation-free methods at every noise level for this dataset.In fact, kNN-RAD is competitive with domain-aware methods such as GDS and GUW across noise levels. Here kNN-SELF falls behind kNN-RAD and END, but still achieves significantly more robustness than vanilla SELF. Note the relatively higher variance of WGA for SELF and kNN-SELF; this is likely due to the downsampling step that induces different data distributions for different seeds.For the Waterbirds dataset, we see in Table 5 that kNN-RAD strongly outperforms END and is competitive with domain-aware methods across noise levels, improving the performance of even the oracle methods GDS and GUW. Vanilla RAD experiences a catastrophic failure at 20% label noise and above which kNN-RAD is able to correct. SELF performs well at 0% label noise, but quickly degrades with label noise. kNN-SELF achieves dramatic gains over vanilla SELF and maintains an edge over END at every noise level.For the CivilComments dataset, we see in Table 6 that kNN-RAD is able to match the performance of the domain-aware methods without having access to domain information. Additionally, kNN label spreading demonstrates significant gains over vanilla RAD. SELF struggles on CivilComments even in the experiments of LaBonte et al. [11] , so it is no surprise that it performs poorly here. The heavy class imbalance is likely the culprit combined with the class balancing performed in Algorithm 2.Table 3 : CMNIST WGA (std. dev.): GUW * and GDS * denote the worst-group accuracies of upweighting and downsampling, respectively, achieved with oracle access to clean domain labels which aren't available to the two-stage methods. We list both the best domain annotation-free method for each noise level and the method within one standard deviation of the best in bold. We see that CMNIST is a relatively easy dataset in general, so label noise does not cause dramatic performance loss. Yet, kNN provides some additional robustness for both RAD and SELF. CMNIST is not considered in [16] Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?Answer: [Yes] Justification: Full experimental details are provided in the appendix including datasets, model details, and hyperparameters. Algorithms are included in the main body. Code will be released publically on GitHub and is included as supplemental material. Guidelines:• The answer NA means that the paper does not include experiments.• If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not. • If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.• Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed. • While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. , with an open-source dataset or instructions for how to construct the dataset). (d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility.In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results. 
discussion and limitations: 
 We observe that kNN label spreading dramatically increases the robustness of both RAD and SELF and additionally find several interesting trends that warrant discussion. First, it is clear that for larger noise levels, a larger number of nearest neighbors is needed to correct for the noise. This is suggested by Gao et al. [5] for large k, but is empirically verified with our experiments. The empirically optimal k value increases with each increase in label noise, which allows the label spreading to average over a larger number of nearest neighbors. For CMNIST, we must use a smaller, but still increasing, k to account for the smaller clusters within classes. A limitation of our method is that k is chosen as a hyperparameter, but these insights help to suggest likely ranges for the optimal. Indeed, if an estimate of the noise prevalence is available, the choice of k nearest neighbors could reasonably be estimated without hyperparameter tuning at all.We also note that the quality of the embeddings is crucial in the selection of the number of neighbors and the number of spreading rounds. CMNIST is the prime example of a dataset that is generally well-separated but has not yet experienced "neural collapse," so each class has several clusters of points. The danger of this is that some clusters may be nearer to the opposite class than their own, requiring fewer nearest neighbors to prevent noisy labels from spreading. The base model accuracy can help indicate how extensively it is trained, though embeddings can also be analyzed qualitatively.As pointed out in Section 3, a limitation of our method is that we assume that embeddings are from a model trained on clean data, but this need not be the case. Indeed Iscen et al. [9] use the robustness of embeddings to label noise in order to train robust deep learning models and we verify the robustness of kNN-RAD in particular in Section 4.3. Finally, we note that while kNN label spreading works well with both SELF and RAD, the downsampling to balance the class aspect of the SELF algorithm combined with label spreading leads to a much larger variance than with kNN-RAD. That said, preprocessing with a kNN label spreading module still achieves significant gains in worst-group accuracy relative to vanilla SELF. A coupled label cleaning and error set selection process may be an interesting direction for future work. By leaving our preprocessing generic, we can ensure our method is applicable when future two-stage methods are developed.Our work allows for the robustness of two-stage fairness corrections, which could improve fairness for minority groups in a wide variety of models. Unfortunately, no two-stage last layer correction can provide guarantees on the fairness of the resulting model in the general setting. This could lead to practitioners assuming fairness without auditing it.The upstream base models for all the datasets which are considered are taken from [22] . This includes all the hyperparameters, data augmentations and training procedures that we use for the upstream models. We use these base models to generate the embeddings for the predefined validation and test splits of the datasets. In our experimental setup, we assume access to a small set of clean data which we use for validation and hyperparameter selection. We split the validation data into two halves. One half is used as the aforementioned clean set for validation and the other half is used for training during hyperparameter selection. During the final testing, we use the entire (noisy) validation split for retraining and the test split for testing. Once we do the hyperparameter selection, we run the algorithms over 10 different noise seeds and report the accuracy and variance over these 10 runs. This procedure is repeated for each dataset and each noise level.For the methods that involve only last-layer retraining (either with downsampling or upweighting), we only tune c, which is the inverse of the λ, the ℓ 1 regularization strength. For all datasets, we tune over 10 values equally spaced on the log scale ranging from 1e-4 to 1.For each dataset, we fix the c values for both the identification and retraining models. We get these values from [22] . We tune the upweight factor for each dataset and each noise level.The hyperparameter values and ranges used are given in Table 7 . The identification model is implemented using the PyTorch library and the retraining model is implemented using the sklearn.linear_model.LogisticRegression package. The learning rate (id) is the learning rate of the identification model and the epochs (id) is the number of epochs used to train the identification model.We follow the same procedure for kNN-RAD as we did for RAD but with the added kNN based label spreading preprocessing step. In addition to the upweight factor, we also tune n_neighbors, which is the number of nearest neighbours used in the kNN algorithm. When there is no noise, we fix the n_neighbors value at 1. We use the sklearn.neighbors.KNeighborsClassifier package to perform the label spreading step. The ranges and hyperparameter values used are given in Table 8 .We implemented misclassification-SELF using code adapted from LaBonte et al. [11] so that it would be compatible with our setup where we use pre-generated embeddings from the base models. We fix the finetuning steps which the number of steps of fine-tuning we perform once we construct the class balanced error set. We tune the learning rate and the number of points that are selected for class balancing. The hyperparameter values and ranges used are given in Table 9 A.5 kNN-SELFThe procedure for kNN-SELF is the same as SELF but with the added kNN based label spreading preprocessing step. We fix the hyperparameters using the values selected in the hyperparameter selection in SELF. We additionally tune n_neighbors. We use the sklearn.neighbors.KNeighborsClassifier package to perform the label spreading step. The ranges and hyperparameter values used are given in Table 10 Consider the data distribution introduced in Yao et al. [27] (also used in [26] ) with group-conditional Gaussians aligned such that the difference between means within a class is given by [C 1 , 0, . . . , 0] ∈ R d and the difference between means across classes is given by [0, C 2 , 0, . . . , 0] ∈ R d . That is, we have axis-aligned core and spurious features. Refer to Figure 3 for a visual.Proposition 2 (Axis-Aligned Gaussian Mixture). Let RAD use the fixed upweighting scheme |E C | |E| . For the dataset described above, with C 2 > C 1 > C 0 for sufficiently large C 0 , RAD fails entirely when learning with symmetric label noise p > 0. Otherwise, RAD fails if 1 2 > p > 2π 0 , achieving lower worst-group accuracy than ERM.Proof. We assume that λ, the ℓ 1 regularization strength of the biased classifier, is large enough that only the first (spurious) or second (core) feature is learned. Consider the two cases separately: Spurious Feature is Learned Consider the error set E. It is made of up clean minority samples and noisy majority samples. When upweighting, the effective noise level in the retraining set will increase for the majority and decrease for the minority. For 2π 0 < p < 1 2 , as π 0 goes to 0, the effective noise in the upweighted majority is 50% and 0% in the upweighted minority. In this case, the optimal separator will split the majorities and correctly classify the minorities. By assumption, C 2 > C 1 so the ℓ 1 penalty in the retraining step will force the spurious feature to be learned again. Note that ERM would learn a classifier biased to the majorities, but not be restricted to only the spurious feature. Thus RAD performs worse than ERM.Core Feature is Learned The error set E now consists of entirely noisy samples which are upweighted by a factor of 1-p p . This results in an effective noise level at retraining of 50%, making the retraining task impossible. Thus RAD fails.It may be tempting to believe that simply using a robust loss should be enough to make two-step methods robust to label noise. The issue is that while robust losses can learn a classifier which performs well on clean data, it will (correctly) misclassify noisy examples. This leads to noisy points (which will much more likely to be from a majority group) being selected for the error set which is used to retrain the final classifier. Thus the final classifier will not be trained on data from minority groups as intended, but on mostly majority points, exacerbating unfairness. To demonstrate this, we train RAD [22] using α-loss in the identification step. α-loss [23] has been demonstrated to be robust to symmetric label noise both theoretically [24] and empirically [24, 23] .We first examine the types of points which are selected by RAD in the error set. In Figure 4 we see that for all noise levels, true minority examples are misclassified (and therefore selected) but as the noise increases, the amount of noisy (former) majority points increases as well. These points drown out the effect of the true minority points, causing failure of RAD at large noise levels. We see in the Table 11 that even when training with this robust loss, worst-group accuracy experiences a dramatic dropoff at larger noise levels. This is the same failure mode that is demonstrated with vanilla cross entropy loss in the main text Section 4. Justification: We propose a drop-in correction which is able to achieve SOTA worst-group accuracy across several datasets as claimed in the abstract.• The answer NA means that the abstract and introduction do not include the claims made in the paper. • The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers. • The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings. • It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material? Answer: [Yes] Justification: Code is included in supplemental materials along with documentation. Code will additionally be released on GitHub after acceptance. Guidelines:• The answer NA means that paper does not include experiments requiring code. Guidelines:• The answer NA means that the paper does not include experiments.• The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them. • The full details can be provided either with the code, in appendix, or as supplemental material. 
experiment statistical significance: 
 Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?Answer: [Yes]Justification: Standard deviation of presented results are given over 10 independent runs.Guidelines:• The answer NA means that the paper does not include experiments.• The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper. • The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions). • The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.) • The assumptions made should be given (e.g., Normally distributed errors). • It should be clear whether the error bar is the standard deviation or the standard error of the mean. • It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified. • For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates). • If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text. 
experiments compute resources: 
 Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?Answer: [Yes]Justification: These details are provided in the appendix.Guidelines:• The answer NA means that the paper does not include experiments.• The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage. • The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute. • The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper). 
code of ethics: 
 Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines?Justification: Every step is taken to ensure that the code of ethics is adhered to, including providing resources for reproducibility and discussions on limitations and societal impact.Guidelines:• The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.• If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics. • The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction). 
broader impacts: 
 Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?Answer: [Yes]Justification: Impacts and limitations are discussed in the "Discussion and Limitations" section. Included are both positive and negative societal impacts.Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?Answer: [NA] Justification: No models are released and all data used is from publicly available datasets.Guidelines:• The answer NA means that the paper poses no such risks.• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.• Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper. • We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution. • For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.38th Conference on Neural Information Processing Systems (NeurIPS 2024). 
 
 Appendix:  


Decision: This paper proposes a robust method for last layer fair model corrections, which tackles the problem of worst group accuracy when the labels are noisy.  Their method uses label spreading from a latent NN graph as a corrective measure on top of last layer fairness correction.  The paper addresses an important problem in fair ML, and constitutes an advance in one of the few effective fairness corrections.  The authors do a good job of highlighting the vulnerability of existing methods.  The reviewers note the strength of the theoretical justification of the method, and the empirical comparisons (which include ablation studies).  Finally, the authors address several criticisms in a revision, particularly regarding the optimal selection of k.  A few weaknesses were pointed out, including limited comparison to other label propagation techniques, and the potentially restrictiveness of the assumptions.

Reviews: review: paper_summary: paper_summary: This paper examines the recently introduced last-layer retraining (LLR) method, which focuses on reweighting features to ensure fairness and improve worst-group performance with minimal group annotation. The authors point out the shortcomings of the LLR method, particularly when label noise is present. To address this, they propose a label correction method using label propagation, assuming that LLR operates on largely separable embeddings. This new approach enhances the performance of state-of-the-art LLR methods under label noise.
strength_weakness: strength_weakness: - The work relies on assumptions such as the need for clean data and the availability of high-quality embeddings.
- Lack of originality.
- Missing recent work [1] which identifies minority groups without using an early-stopped model, instead relying on unsupervised object-centric concept discovery.
questions: questions: - The authors assume the need for clean data, which I believe is a strong assumption for real-world applications. How do RAD and SELF perform when using only the clean data (set aside for validating the proposed method), given that these methods are designed to be sample-efficient alternatives?
- Can the authors show effectiveness of the proposed method in multi-class and multi-bias dataset [2]?

References

[1] Arefin, Md Rifat, et al. "Unsupervised Concept Discovery Mitigates Spurious Correlations." Forty-first International Conference on Machine Learning, 2024.

[2] Li, Zhiheng, et al. "A whac-a-mole dilemma: Shortcuts come in multiples where mitigating one amplifies others." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2023.
limitations: limitations: Limitations of the work is discussed well in the paper.
paper_summary: paper_summary: This paper addresses the challenge of improving worst-group accuracy (WGA) in machine learning models, particularly in the presence of noisy labels. The authors focus on last-layer retraining (LLR) methods, which have emerged as an efficient approach for correcting existing base models to ensure fairness across subgroups.

The key contributions of the paper are:

1. Highlighting the vulnerability of state-of-the-art LLR methods, specifically SELF and RAD, to label noise in the training data.

2. Introducing a novel label correction preprocessing method based on k-nearest neighbors (kNN) label spreading. This method significantly improves the performance of LLR methods under label noise conditions.

3. Proposing two new algorithms, kNN-RAD and kNN-SELF, which combine the kNN label spreading technique with existing LLR methods (RAD and SELF, respectively).

4. Demonstrating the effectiveness of their approach across various spurious correlation datasets, including CMNIST, CelebA, Waterbirds, and CivilComments.

The authors show that their proposed methods, particularly kNN-RAD, achieve state-of-the-art performance in terms of worst-group accuracy without requiring domain annotations during training. The approach is competitive with, and in some cases outperforms, domain-aware methods and full model retraining approaches like END.

The paper provides both theoretical insights and empirical evidence for the effectiveness of kNN label spreading in correcting noisy labels. It also discusses the relationship between the optimal number of nearest neighbors and the level of label noise, offering practical guidance for implementing the method.

Overall, this work presents a simple yet effective approach to enhancing the robustness of last-layer retraining methods for improving worst-group accuracy in the presence of label noise, addressing an important challenge in the field of fair machine learning.
strength_weakness: strength_weakness: While the paper presents valuable contributions, there are some areas where it could be improved:

1. Limited theoretical analysis:
   The paper provides some theoretical insights, particularly referencing Gao et al.'s work on kNN classification with label noise. However, a more rigorous theoretical analysis specific to this method could strengthen the paper. For instance:
   - A formal proof of convergence for the label spreading algorithm in this context.
   - Theoretical bounds on the expected improvement in worst-group accuracy after applying kNN label spreading.
   - An analysis of how the method's performance depends on the separation of classes in the embedding space.

2. Sensitivity to hyperparameters:
   The authors acknowledge that the choice of k (number of nearest neighbors) is crucial and depends on the noise level. While they provide some empirical guidance, a more systematic approach to selecting k would be beneficial. For example:
   - A heuristic method for estimating the optimal k based on dataset characteristics and estimated noise level.
   - An analysis of the method's sensitivity to suboptimal choices of k.

3. Assumptions about embedding quality:
   The method relies heavily on the quality of the embeddings from the base model. While the authors discuss this limitation, they could expand on:
   - How the method performs when the base model is trained on noisy data, violating the clean data assumption.
   - Potential approaches to improve embedding quality in the presence of noisy labels.

4. Limited exploration of other label propagation techniques:
   The paper focuses on kNN label spreading, but other label propagation techniques exist. A brief comparison with alternative methods (e.g., graph-based label propagation) could provide more context for the choice of kNN.

5. Comparison with other robust learning methods:
   While the paper compares with END and domain-aware methods, a comparison with other robust learning techniques (e.g., importance reweighting, robust loss functions) could provide more context for the method's effectiveness.
questions: questions: 1. Robustness to noisy embeddings:
   Question: How does the performance of kNN-RAD and kNN-SELF change when the base model is trained on noisy data, violating the clean data assumption for embeddings?

2. Optimal selection of k nearest neighbors:
   Question: Given that the optimal number of nearest neighbors ($k$) depends on the noise level, which is often unknown in practice, how can practitioners best select this crucial hyperparameter?

3. Extension to multi-class problems:
   Question: How does the proposed method extend to multi-class classification problems, and what additional challenges might arise in this setting?
limitations: limitations: Authors have discussed the limitations sufficiently.
paper_summary: paper_summary: This paper proposes a simple kNN-based label noise correction strategy to improve the performance of two-stage last-layer retraining methods for group robustness under moderate label noise. The authors show that the performance of RAD and SELF deteriorates quickly when label noise is present in the held-out dataset and show that their kNN method achieves better worst-group accuracy on several benchmark datasets.
strength_weakness: strength_weakness: 1. I encourage the authors to discuss any “baseline” label noise in the given datasets; for instance, Waterbirds is known to contain incorrect labels [1] and therefore the standard dataset has non-zero label noise. This suggests that methods like RAD and SELF might already be robust to a small amount of label noise.

2. I am confused by the assumptions in Section 2. It is stated that $f$ is a neural network pretrained on clean data, whose last layer is then retrained to obtain the final model. What exactly is this pretraining dataset? Is it the weight initialization (e.g. ImageNet) or the downstream dataset used for ERM finetuning (e.g. Waterbirds)? If it is the former, I believe the assumption is justified, but the training procedure should be clarified to include a round of ERM finetuning. If it is the latter, I believe the assumption is not justified, as the held-out set for LLR is essentially a random subset of the finetuning dataset and should therefore obey the same label distribution. Indeed, if the finetuning dataset was clean but the held-out dataset was noisy, one should just throw out the held-out dataset and hold out a subset of the finetuning dataset instead.

3. The authors focus on the “misclassification” version of the SELF algorithm. However, [2] shows that misclassification is actually the worst version of SELF, particularly on CivilComments, and they ultimately propose early-stop disagreement SELF which has much better performance. What is the justification for using the misclassification version of SELF when its initial performance is so low, and why is disagreement SELF not used? I wonder if this would also help with the variance problem of kNN-SELF noted in Section 5, as [2] show reduced variance using the disagreement technique as well.

***References***

[1] Taghanaki et al. “MaskTune: Mitigating Spurious Correlations by Forcing to Explore”. NeurIPS 2022.

[2] LaBonte et al. “Towards Last-layer Retraining for Group Robustness with Fewer Annotations”. NeurIPS 2023.
questions: questions: 1. Should lowercase $x_j$ be used in Section 3 instead of uppercase? I thought uppercase $X$ represented the entire dataset while lowercase $x_j$ was a single point.
2. Are group annotations necessary for hyperparameter tuning of the kNN methods? This is an important limitation and should be made more explicit.
3. Regarding Weakness #2, what is the performance of the proposed method if the finetuning dataset is noisy?
limitations: limitations: The limitations and social impact of the proposed kNN method are sufficiently discussed, but my concerns from the Weaknesses section may constitute important limitations if not addressed.

Comments: title: Thanks for your response
comment: Thank you for your response, we will be sure to include the complete set of experiments and discussion in the final version of the paper. Thank you again for your suggestions.
Thank you to the authors for addressing my questions. The authors presented preliminary experiments regarding my concern about the clean data assumption, where they claim their method shows improvement over RAD and SELF. However, it is unclear why RAD and SELF perform differently on CelebA and Waterbirds, and the significance of their improvement when other methods are trained on similarly clean data. I recommend finishing these experiments and including them in the paper, along with a detailed discussion of the sample complexity of each experiment. Considering the importance of the problem studied and the promising results, I have decided to increase my score.
We are very grateful to the reviewer for their valuable suggestions, especially regarding new baselines. We believe that we were able to address the reviewer’s concerns and hope that it warrants an increase in score.
Thanks to the authors for their comprehensive response.

For (W2), my concerns have been partially addressed, especially with the good performance of the kNN method using noisy finetuning datasets -- though I still have reservations about the practicality of the clean finetuning dataset assumption, since in practice one could just perform LLR/RAD/SELF using a held-out subset of the clean dataset. I look forward to reading more comprehensive experiments on noisy finetuning datasets in the final version.

For (W3), the authors bring up an interesting point about whether disagreement can solve the problem of noisy labels. In [2] the authors provide some discussion on this matter, as they claim misclassification selects "difficult" data (more likely to be noisy) while disagreement selects "uncertain" data (more likely to be legitimate minority group data). While somewhat orthogonal to the proposed kNN method, it would be valuable to the community to provide some discussion of this point, perhaps including experiments showing whether misclassification or disagreement methods are better at filtering noisy labels.

Regardless, though, I think some comparison to early-stop disagreement SELF should be included (and the authors can justify in the text that the numbers are not directly comparable due to the additional information of an early-stopped model), since [2] is clear that misclassification SELF is not the recommended method. In fact, they get much better performance on CivilComments by training on a *random* subset of data.

For (Q2), I suggest that the authors include model selection using worst-class accuracy [4] or the bias-unsupervised validation score [5] in the final version. These are recent proposals for proxy methods that do not use group annotations; they seem to perform well and are not difficult to implement.

**Recommendation**

Overall, this paper is borderline for me. The problem is important and the proposed method is interesting, but I have remaining concerns about the assumptions, evaluations, and comparisons as discussed above. With that said, I now lean slightly towards acceptance instead of rejection, so I have raised my score to a 5.

**References**

[2] LaBonte et al. “Towards Last-layer Retraining for Group Robustness with Fewer Annotations”. NeurIPS 2023.

[4] Yang et al. "Change is Hard: A Closer Look at Subpopulation Shift". ICML 2023.

[5] Tsirigotis et al. "Group Robust Classification Without Any Group Information". NeurIPS 2023.
We are glad that we could address your concerns. We believe that the incorporation of these points into our paper significantly strengthens our submission, and we hope that you consider increasing your score accordingly.
Thank you for your detailed response. I think it generally addresses my concerns and answers my questions.