Year: 2021

Abstract:
While unbiased machine learning models are essential for many applications, bias is a human-defined concept that can vary across tasks. Given only input-label pairs, algorithms may lack sufficient information to distinguish stable (causal) features from unstable (spurious) features. However, related tasks often share similar biases – an observation we may leverage to develop stable classifiers in the transfer setting. In this work, we explicitly inform the target classifier about unstable features in the source tasks. Specifically, we derive a representation that encodes the unstable features by contrasting different data environments in the source task. We achieve robustness by clustering data of the target task according to this representation and minimizing the worst-case risk across these clusters. We evaluate our method on both text and image classifications. Empirical results demonstrate that our algorithm is able to maintain robustness on the target task for both synthetically generated enviornments and real-world environments. Our code will be publicly available.

heading: 1 INTRODUCTION
text: Automatic de-biasing (Sohoni et al., 2020; Creager et al., 2021; Sanh et al., 2021) has emerged as a promising direction for learning stable classifiers. The key premise here is that no additional annotations for the bias attribute are required. However, bias is a human-defined concept and can vary from task to task. Provided with only input-label pairs, algorithms may not have sufficient information to distinguish stable (causal) features from unstable (spurious) features.
To address this challenge, we note that related tasks are often fraught with similar spurious correlations. For instance, when classifying animals such as camels vs. cows, their backgrounds (desert vs. grass) may constitute a spurious correlation (Beery et al., 2018). The same bias between the label and the background also persists in other related classification tasks (such as sheep vs. antelope). In the resource-scarce target task, we only have access to the input-label pairs. However, in the source tasks, where training data is sufficient, identifying biases may be easier. For instance, we may have examples collected from multiple environments, in which correlations between bias features and the label are different (Arjovsky et al., 2019). These source environments help us define the exact bias features that we want to regulate.
One obvious approach to utilize the source task is direct transfer. Specifically, given multiple source environments, we can train an unbiased source classifier and then apply its representation to the target task. However, we empirically demonstrate that while the source classifier is not biased when making its final predictions, its internal continuous representation can still encode information about the unstable features. Figure 1 shows that in Colored MNIST, where the digit label is spuriously correlated with the image color, direct transfer by either re-using or fine-tuning the representation learned on the source task fails in the target task, performing no better than the majority baseline.
In this paper, we propose to explicitly inform the target classifier about unstable features from the source data. Specifically, we derive a representation that encodes these unstable features using the source environments. Then we identify distinct subpopulations by clustering examples based on this representation and apply group DRO (Sagawa et al., 2019) to minimize the worst-case risk over these subpopulations. As a result, we enforce the target classifier to be robust against different values of the unstable features. In the example above, animals would be clustered according to backgrounds, and the classifier should perform well regardless of the clusters (backgrounds).
The remaining question is how to compute the unstable feature representation using the source data environments. Following Bao et al. (2021), we hypothesize that unstable features are reflected in mistakes observed during classifier transfer across environments. For instance, if the classifier uses the background to distinguish camels from cows, the camel images that are predicted correctly would have a desert background while those predicted incorrectly are likely to have a grass background. More generally, we prove that among examples with the same label value, those with the same prediction outcome will have more similar unstable features than those with different predictions. By forcing examples with the same prediction outcome to stay closer in the feature space, we obtain a representation that encodes these latent unstable features.
We evaluate our approach, Transfer OF Unstable features (TOFU), on both synthetic and realworld environments. Our synthetic experiments first confirm our hypothesis that standard transfer approaches fail to learn a stable classifier for the target task. By explicitly transferring the unstable features, our method significantly improves over the best baseline across 12 transfer settings (22.9% in accuracy), and reaches the performance of an oracle model that has direct access to the unstable features (0.3% gap). Next, we consider a practical setting where environments are defined by an input attribute and our goal is to reduce biases from other unknown attributes. On CelebA, TOFU achieves the best worst-group accuracy across 38 latent attributes, outperforming the best baseline by 18.06%. Qualitative and quantitative analyses confirm that TOFU is able to identify the unstable features.

heading: 2 RELATED WORK
text: Removing bias via annotations: Due to idiosyncrasies of the data collection process, annotations are often coupled with unwanted biases (Buolamwini and Gebru, 2018; Schuster et al., 2019; McCoy et al., 2019; Yang et al., 2019). To address this issue and learn robust models, researchers leverage extra information (Belinkov et al., 2019; Stacey et al., 2020; Hinton, 2002; Clark et al., 2019; He et al., 2019; Mahabadi et al., 2020). One line of work assumes that the bias attributes are known and have been annotated for each example, e.g., group distributionally robust optimization (DRO) (Hu et al., 2018; Oren et al., 2019; Sagawa et al., 2020). By defining groups based on these bias attributes, we explicitly specify the distribution family to optimize over. However, identifying the hidden biases is time-consuming and often requires domain knowledge (Zellers et al., 2019; Sakaguchi et al., 2020). To address this issue, another line of work (Peters et al., 2016; Krueger et al., 2020; Chang et al., 2020; Jin et al., 2020; Ahuja et al., 2020; Arjovsky et al., 2019; Bao et al., 2021; Kuang et al., 2020; Shen et al., 2020) only assumes access to a set of data environments. These environments are defined based on readily-available information of the data collection circumstances, such as location and time. The main assumption is that while spurious correlations vary across different environments, the association between the causal features and the label should stay the same. Thus, by learning a representation that is invariant across all environments, they alleviate the dependency on spurious features. In contrast to previous works, we don’t have access to any additional information besides the labels in our target task. We show that we can achieve robustness by transferring the unstable features from a related source task.
Automatic de-biasing A number of recent approaches focus on a more common setting where the algorithm only has access to the input-label pairs. Sanh et al. (2021); Nam et al. (2020); Utama et al. (2020) find that weak models are more vulnerable to spurious correlations as they only learn shallow heuristics. By boosting from their mistakes, they obtain a more robust model. Qiao et al. (2020) uses adversarial learning to augment the biased training data. Creager et al. (2021); Sohoni et al. (2020); Ahmed et al. (2020); Matsuura and Harada (2020); Liu et al. (2021) propose to identify minority groups by looking at the features produced by a biased model.
These automatic approaches are intriguing as they do not require additional annotation. However, we note that bias is a human-centric concept and can vary from tasks to tasks. For models that only have access to the input-label pairs, they have no information to distinguish causal features from bias features. For example, consider the Colored MNIST dataset, where color and digit shape are correlated in the training set but not in the test set. If our task is to predict the digit, then color becomes the spurious bias that we want to remove. Vice versa, if we want to predict the color, then digit shape is spurious. Creager et al. (2021); Nam et al. (2020) empirically demonstrate that they can learn a color-invariant model for the digit prediction task. However, their approaches will result in the same color-invariant model for the color prediction task, and thus fail at test time, when color and digit are no longer correlated. In this work, we leverage source tasks to define the exact bias that we want to remove for the target task.
Transferring robustness across tasks: Prior work has also studied the transferability of adversarial robustness across tasks. For example, Hendrycks et al. (2019); Shafahi et al. (2020) show that by pre-training the model on a large-scale source task, we can improve the model robustness against adversarial perturbations over l∞ norm. We note that these perturbations measure the smoothness of the classifier, rather than the stability of the classifier against spurious correlations. In fact, our results show that if we directly re-use or fine-tune the pre-trained feature extractor on the target task, the model will quickly over-fit to the unstable correlations present in the data. We propose to address this issue by explicitly inferring the unstable features using the source environments and use this information to guide the target classifier during training.

heading: 3 METHOD
text: Problem formulation We consider the transfer problem from a source task to a target task. For the source task, we assume the standard setting (Arjovsky et al., 2019) where the training data contain n environments E1, . . . , En. Within each environment Ei, examples are drawn from the joint distribution Pi(x, y). Following Woodward (2005), we define unstable features Z(x) as features that are differentially correlated with the label across the environments. We note that Z(x) is unknown to the model.
For the target task, we only have access to the input-label pairs (x, y) (i.e. no environments). We assume that the target label is not causally associated with the above unstable features Z . However, due to collection biases, the target data may contain spurious correlations between the label and Z . Our goal is to transfer the knowledge that Z is unstable in the source task, so that the target classifier will not rely on these spurious features.
Overview If the unstable features have been identified for the target task, we can simply apply group DRO to learn a stable classifier. By grouping examples based on the unstable features and minimizing the worst-case risk over these manually-defined groups, we explicitly address the bias from these unstable features (Hu et al., 2018; Oren et al., 2019; Sagawa et al., 2020). In our setup, while these unstable features are not accessible, we can leverage the source environments to derive groups over the target data that are informative of these biases. Applying group DRO on these automatically-derived groups, we can eliminate the unstable correlations in the target task.
Our overall transfer paradigm is depicted in Figure 2. It consists of two steps: inferring unstable features from the source task (Section 3.1) and learning stable correlations for the target task (Section 3.2). First, for the source task we use a classifier trained on one environment to partition data from another environment based on the correctness of its predictions. Starting from the theoretical results in (Bao et al., 2021), we show that these partitions reflect the similarity of the examples in terms of their unstable features: among examples with the same label value, those that share the same prediction
outcome have more similar unstable features than those with different predictions (Theorem 1). We can then derive a representation fZ where examples are distributed based on the unstable features Z . Next, we cluster target examples into groups based on the learned unstable feature representation fZ . These automatically-derived groups correspond to different modes of the unstable features, and they act as proxies to the manually-defined groups in the oracle setting where unstable features are explicitly annotated. Finally, we use group DRO to obtain our robust target classifier by minimizing the worst-case risk over these groups.

heading: 3.1 INFERRING UNSTABLE FEATURES FROM THE SOURCE TASK
text: Given the data environments from the source task, we would like to 1) identify the unstable correlations across these environments; 2) learn a representation fZ(x) that encodes the unstable features Z(x). We achieve the first goal by contrasting the empirical distribution of different environments (Figure 2.S.1 and Figure 2.S.2) and the second goal by metric learning (Figure 2.S.3).
Let Ei and Ej be two different data environments. Bao et al. (2021) shows that by training a classifier fi on Ei and using it to make predictions on Ej , we can reveal the unstable correlations from its prediction results. Intuitively, if the unstable correlations are stronger in Ei, the classifier fi will overuse these correlations and make mistakes on Ej when these stronger correlations do not hold.1
In this work, we connect the prediction results directly to the unstable features. We show that the prediction results of the classifier fi on Ej estimate the relative distance of the unstable features.
Theorem 1 (Simplified). Consider examples in Ej with label value y. Let XX1 , XX2 denote two batches of examples that fi predicted correctly, and let X×3 denote a batch of incorrect predictions. We use · to represent the mean across a given batch. Following the same assumption in (Bao et al., 2021), we have
‖Z(XX1 )−Z(XX2 )‖2 < ‖Z(XX1 )−Z(X×3 )‖2 1We assume that the distributions of Ei and Ej are different enough such that fi will make mistakes.
almost surely for large enough batch size.2.
The result makes intuitive sense as we would expect example pairs that share the same prediction outcome should be more similar than those with different prediction outcomes. We note that it is critical to look at examples with the same label value; otherwise, the unstable features will be coupled with the task-specific label in the prediction results.
While the value of the unstable features Z(x) is still not directly accessible, Theorem 1 enables us to learn a feature representation fZ(x) that preserves the distance between the examples in terms of their unstable features. We adopt standard metric learning (Chechik et al., 2010) to minimize the following triplet loss:
LZ(XX1 , XX2 , X×3 ) = max(0, ‖fZ(XX1 )− fZ(XX2 )‖22 − ‖fZ(XX1 )− fZ(X×3 )‖22 + δ), (1)
where δ is a hyper-parameter. By minimizing Eq equation 1, we encourage examples that have similar unstable features to be close in the representation fZ . To summarize, inferring unstable features from the source task consists of three steps (Figure 2.S):
S.1 For each source environment Ei, train an environment-specific classifier fi.
S.2 For each pair of environments Ei and Ej , use classifier fi to partition Ej into two sets: EiXj and Ei×j , where E iX j contains examples that fi predicted correctly and E i× j contains those
predicted incorrectly.
S.3 Learn an unstable feature representation fZ by minimizing Eq equation 1 across all pairs of environments Ei, Ej and all possible label value y:
fZ = argmin ∑
y,Ei 6=Ej EXX1 ,XX2 ,X×3
[ LZ(XX1 , XX2 , X×3 ) ] ,
where batches XX1 , X X 2 are sampled uniformly from E iX j |y and batch X×3 is sampled uniformly from Ei×j |y (·|y denotes the subset of · with label value y).

heading: 3.2 LEARNING STABLE CORRELATIONS FOR THE TARGET TASK
text: Given the unstable feature representation fZ , our goal is to learn a target classifier that focuses on the stable correlations rather than using unstable features. Inspired by group DRO (Sagawa et al., 2020) we minimize the worst-case risk across groups of examples that are representative of different unstable feature values. However, in contrast to DRO, these groups are constructed automatically based on the previously learned representation fZ .
For each target label value y, we use the representation fZ to cluster target examples with label y into different clusters (Figure 2.T.1). Since these clusters capture different modes of the unstable features, they are approximations of the typical manually-defined groups when annotations of the unstable features are available. By minimizing the worst-case risk across all clusters, we explicitly enforce the classifier to be robust against unstable correlations (Figure 2.T.2). We note that it is important to cluster within examples of the same label, as opposed to clustering the whole dataset. Otherwise, the cluster assignment may be correlated with the target label.
Concretely, learning stable correlations for the target task has two steps (Figure 2.T).
T.1 For each label value y, apply K-means (l2 distance) to cluster examples with label y in the feature space fZ . We use C y 1 , . . . , C y nc to denote the resulting cluster assignment, where nc
is a hyper-parameter.
T.2 Train the target classifier f by minimizing the worst-case risk over all clusters:
f = argminmax i,y L(Cyi ),
where L(Cyi ) is the empirical risk on cluster Cyi .
Table 1: Pearson correlation coefficient between the spurious feature Z and the label Y for each task. The validation environment Eval follows the same distribution as Etrain1 . We study the transfer problem between different task pairs. For the source task S, the model can access Etrain1 (S), E train
2 (S)
and Eval(S). For the target task T , the model can access Etrain1 (T ) and E val(T ).
ρ(Z, Y ) MNIST BEER REVIEW ASK2ME WATERBIRD ODD EVEN LOOK AROMA PALATE PENE. INCI. WATER SEA.
E train1 0.87 0.87 0.60 0.60 0.60 0.31 0.44 0.36 0.39
E train2 0.75 0.75 0.80 0.80 0.80 0.52 0.66 0.63 0.64
Eval 0.87 0.87 0.60 0.60 0.60 0.31 0.44 0.36 0.39
E test −0.11 −0.11 −0.80 −0.80 −0.80 0.00 0.00 0.00 0.00

heading: 4 EXPERIMENTAL SETUP

heading: 4.1 DATASETS AND SETTINGS
text: Synthetic environments We start with controlled experiments where environments are created based on the spurious correlation. We consider four datasets: MNIST (LeCun et al., 1998), BeerReview (McAuley et al., 2012), ASK2ME (Bao et al., 2019a) and Waterbird (Sagawa et al., 2019). In MNIST and BeerReview, we inject spurious feature to the input (background color for MNIST and pseudo token for BeerReview). In ASK2ME and Waterbird, spurious feature corresponds to an attribute of the input (breast cancer for ASK2ME and background for Waterbird).
For each dataset, we consider multiple tasks and study the transfer between these tasks. Specifically, for each task, we split its data into four environments: Etrain1 , E train 2 , E
val, Etest, where spurious correlations vary across the two training environments Etrain1 , E train 2 . For the source task S, the model can access both of its training environments Etrain1 (S), E train 2 (S). For the target task T , the model only has access to one training environment Etrain1 (T ). We note that the validation set E val(T ) plays an important role in early-stopping and hyper-parameter tuning, especially when the distribution of the data is different between training and testing (Gulrajani and Lopez-Paz, 2020). In this work, since we don’t have access to multiple training environments on the target task, we assume that the validation data Eval follows the same distribution as the training data Etrain1 . Table 1 summarizes the level of the spurious correlations for different tasks. Additional details can be found in Appendix C.1.3
Natural environments We also consider a practical setting where environments are directly defined by a given attribute of the input, and our goal is to reduce model biases from other latent attributes. We study CelebA (Liu et al., 2015a) where each input (an image of a human face) is annotated with 40 binary attributes. The source task is to predict the Eyeglasses attribute and the target task is to predict the BlondHair attribute. We use the Young attribute to define two environments: E1 = {Young = 0} and E2 = {Young = 1}. In the source task, both environments are available. In the target task, we only have access to environment E1 during training and validation. At test time, we evaluate the robustness of our target classifier against other latent attributes. Specifically, for each unknown attribute such as Male, we partition the testing data into four groups: {Male = 1,BlondHair = 0}, {Male = 0,BlondHair = 0}, {Male = 1,BlondHair = 1}, {Male = 0,BlondHair = 1}. Following Sagawa et al. (2019), We report the worst-group accuracy and the average-group accuracy.

heading: 4.2 BASELINES
text: We compare our algorithm against the following baselines. For fair comparison, all methods share the same representation backbone and hyper-parameter search space.
ERM baseline We learn a classifier on the target task from scratch by minimizing the average loss across all examples. Note that this classifier is independent of the source task. Its performance reflects the deviation between the training distribution and the testing distribution of the target task.
2See Appendix B for the full theorem and proof. 3All data splits, hyper-parameter search spaces are available in the supplementary materials.
Transfer methods Since the source task contains multiple environments, we can learn a stable model on the source task and transfer it to the target task. We use four algorithms to learn the source task: DANN (Ganin et al., 2016), C-DANN (Li et al., 2018b), MMD (Li et al., 2018a), PI (Bao et al., 2021). We consider three standard methods for transferring the source knowledge:
REUSE: We directly transfer the feature extractor of the source model to the target task. The feature extractor is fixed when learning the target classifier.
FINETUNE: We update the feature extractor when training the target classifier. (Shafahi et al., 2020) has shown that FINETUNE may improve adversarial robustness of the target task.
MULTITASK: We adopt the standard multi-task learning approach (Caruana, 1997) where the source model and the target model share the same feature extractor and are jointly trained together.
Automatic de-biasing methods For the target task, we can also apply de-biasing approaches that do not require environments. We consider the following baselines:
EIIL (Creager et al., 2021): Based on a pre-trained ERM classifier’s prediction logits, we infer an environment assignment that maximally violates the invariant learning principle (Arjovsky et al., 2019). We then apply group DRO to minimize the worst-case loss over all inferred environments.
GEORGE (Sohoni et al., 2020): We use the feature representation of a pre-trained ERM classifier to cluster the training data. We then apply group DRO to minimize the worst-case loss over all clusters.
LFF (Nam et al., 2020): We train a biased classifier together with a de-biased classifier. The biased classifier amplifies its bias by minimizing the generalized cross entropy loss. The de-biased classifier then up-weights examples that are mis-labeled by the biased classifier during training.
M-ADA (Qiao et al., 2020): We use a Wasserstein auto-encoder to generate adversarial examples. The de-biased classifier is trained on both the original examples and the generated examples.
DG-MMLD (Matsuura and Harada, 2020): We iteratively divide target examples into latent domains via clustering, and train the domain-invariant feature extractor via adversarial learning.
ORACLE For synthetic environments, we can use the spurious feature to define groups and train an oracle model. For example, in task SEABIRD, this oracle model will minimize the worst-case

heading: S EIIL 64.71 85.12 64.43 85.96 66.67 83.90 57.62 83.22
text: Figure 3: PCA visualization of the unstable feature representation fZ for examples in MNIST EVEN. fZ is trained on MNIST ODD. TOFU identifies the hidden spurious color feature by contrasting different source environments.
risk over the following four groups: {seabird in water}, {seabird in land} {landbird in water}, {landbird in land}. This oracle model helps us analyze the performance of our proposed algorithm separately from the inherent limitations (such as model capacity and data size).

heading: 5 RESULTS
text: Table 2 summarizes our results on synthetic environments. We observe that standard transfer methods fail to improve over the ERM baseline. On the other hand, TOFU consistently achieves the best
performance across 12 transfer settings, outperforming the best baseline by 22.9%. While TOFU doesn’t have access to the unstable features, by inferring them from the source environments, it matches the oracle performance with only 0.30% absolute difference.
Table 3 presents our results on natural environments. This task is very challenging as there are multiple latent spurious attributes in the training data. We observe that most automatic de-biasing methods underperform the ERM baseline. With the help of the source task, FINETUNE and MULTITASK achieve slightly better performance than ERM. TOFU continues to shine in this real-world setting: achieving the best worst-group and average-group performance.
Is TOFU able to identify the unstable features? Yes. For synthetic environments, we visualize the unstable feature representation produced by fZ on MNIST EVEN. Figure 3 demonstrates that while fZ only sees source examples (ODD) during training, it can distribute target examples based on their unstable color features. For natural environments, we visualize the distribution of two latent attributes (Male and ArchedEyebrows) over the generated clusters. Figure 4 shows that the distribution gap of the unknown attribute Male across the generated partitions is 2% for EIIL, only marginally better than random splitting (0%). By leveraging information from the source task, TOFU learns partitions that are more informative of the unknown attribute (14%).
How do the generated clusters compare to the oracle groups? We quantitatively evaluate the generated clusters based on three metrics: homogeneity (each cluster contain only examples with the same unstable feature value), completeness (examples with the same unstable feature value belong to the same cluster), and V-measure (the harmonic mean of homogeneity and completeness). From Table 4, we see that TOFU is able to derive clusters that resemble the oracle groups on BEER REVIEW. In MNIST, since we generate two clusters for each label value and there are five different colors, it is impossible to recover the oracle groups. However, TOFU still achieves almost perfect completeness.

heading: 6 CONCLUSION
text: Reducing model bias is a critical problem for many machine learning applications in the real world. In this paper, we recognize that bias is a human-defined concept. Without additional knowledge, automatic de-biasing methods cannot effectively distinguish causal features from spurious features. The main departure of this paper is to identify bias by using related tasks. We demonstrate that when the source task and target task share the same set of biases, we can effectively transfer this knowledge and improve the robustness of the target model without additional human intervention. Compared with 15 baselines across 5 datasets, our approach consistently delivers significant performance gain. Quantitative and qualitative analyses confirm that our method is able to identify the hidden biases. Due to space limitations, we leave further discussions to Appendix A.

Review summaries:
The paper is concerned with learning a model in situations when some features have spurious correlations with the label (for example, for classifying sheep vs camel, background can be a spurious feature). The idea is that if a lot of source data is available, these spurious correlation features should be easy to find. To find the unstable features, authors hypothesize that they are related to mistakes that a classifier makes in different environments. Therefore, they learn a model on one environment and run it on a different environment (source data), splitting the data into correctly predicted and not. Then for each partition (correct or not) examples with the same labels are encouraged to be close together, so the embedding learns UNSTABLE features (fz). Then the target data is clustered based on unstable features representation fz, and then DRO (existing method that assumes the existance of correct groupping based on unstable features) is used to train a robust target classifier

This paper aims to transfer the knowledge of spurious correlations in a set of source environments to a target environment. They assume the degree of spurious patterns vary among source environments (e.g. color has different correlations with the number in MNIST), and the spurious pattern are the same in both the source and target tasks. Then they aim to transfer the spurious knowledge from source environments to learn a classifier in the target task that ignores the spurious pattern.   They train the model in 3 stages. First, they train a regular classifier in each environment. E.g. given two source environments E1 and E2, they train the corresponding classifiers f1, f2. Second, they use the error of the f1 on E2 to "separate" the E2 examples into two groups, one group for correct predictions and the other group for the wrong predictions under each class. They assume the cause of the error comes from the spurious patterns, so each group will correspond to either high or low spurious patterns learned in f1. Thus they learn a f_Z that outputs an embedding to separate these two groups by triplet loss. Finally, in the target task, they cluster the examples into different groups by the similarity of f_Z that captures examples with similar spurious patterns. Then they apply Distribution Robust Optimization (DRO) on these groups that optimizes the worst performance across all groups. This ignores the spurious patterns based on f_Z in the target task and learns a stable classifier.

The authors introduce a method (TOFU) for learning classifiers that are robust to spurious correlations in a transfer learning setting. They argue that approaches which rely only on (input, label) pairs and use no extra information to identify spurious features could fail to learn a robust model due to insufficient data for the target task. The authors provide scenarios where useful metadata, namely varying environments, could be available for source tasks, ready to be leveraged by the target task classifier for the purpose of identifying a shared bias that might exist across all tasks. To identify unstable/spurious features, the authors follow a 3-step procedure proposed in an existing work. Namely, a classifier is trained on data from environment E1, and is evaluated on data from a second environment E2. The data in E2 is then partitioned according to the correctness of the classifier's predictions on a per-class basis. A metric learning objective using a triplet loss is used to learn a model which embeds samples according to their unstable features with the goal that the unstable features of the correctly predicted samples should be closer together than unstable features between correctly predicted and incorrectly predicted samples. The objective is justified based on prior theoretical work and is illustrated visually. Extensive empirical evaluations are performed, comparing the performance of TOFU against many different baseline methods on both image and text classification tasks.

The paper considers a transfer problem when the spurious correlations of source tasks can be applied to the target task. The authors propose to identify the unstable features on source tasks first and then cluster the target data according to these features. Finally, an invariance-based method are incorporated to eliminated the influence of unstable features.