L EARNING S TABLE C LASSIFIERS BY T RANSFERRING U NSTABLE F EATURES
Anonymous authors
Paper under double-blind review
A BSTRACT
While unbiased machine learning models are essential for many applications, bias is a human-deﬁned concept that can vary across tasks.
Given only input-label pairs, algorithms may lack sufﬁcient 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 classiﬁers in the transfer setting.
In this work, we explicitly inform the target classiﬁer about unstable features in the source tasks.
Speciﬁcally, 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 classiﬁcations.
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.
I NTRODUCTION
Automatic de-biasing (Sohoni et al., 2020; Creager et al., 2021; Sanh et al., 2021) has emerged as a promising direction for learning stable classiﬁers.
The key premise here is that no additional annotations for the bias attribute are required.
However, bias is a human-deﬁned concept and can vary from task to task.
Provided with only input-label pairs, algorithms may not have sufﬁcient 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 classiﬁcation 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 sufﬁcient, 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 deﬁne the exact bias features that we want to regulate.
One obvious approach to utilize the source task is direct transfer.
Speciﬁcally, given multiple source environments, we can train an unbiased source classiﬁer and then apply its representation to the target task.
However, we empirically demonstrate that while the source classiﬁer is not biased when making its ﬁnal 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 ﬁne-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 classiﬁer about unstable features from the source data.
Speciﬁcally, 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 classiﬁer to be robust against different values of the unstable features.
In the example above, animals would be clustered according to backgrounds, and the classiﬁer should perform well regardless of the clusters (backgrounds).
[Figure]
spurious correlation able to reach the oracle
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 reﬂected in mistakes observed during classiﬁer transfer across environments.
For instance, if the classiﬁer 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 ﬁrst conﬁrm our hypothesis that standard transfer approaches fail to learn a stable classiﬁer for the target task.
By explicitly transferring the unstable features, our method signiﬁcantly 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 deﬁned 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 conﬁrm that TOFU is able to identify the unstable features.
R ELATED WORK
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 deﬁning 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 deﬁned 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.
; Nam et al.
Utama et al.
ﬁnd 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.
; Sohoni et al.
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.
; 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 deﬁne 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.
; 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 classiﬁer, rather than the stability of the classiﬁer against spurious correlations.
In fact, our results show that if we directly re-use or ﬁne-tune the pre-trained feature extractor on the target task, the model will quickly over-ﬁt 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 classiﬁer during training.
M ETHOD
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 E 1 , . . .
, E n .
Within each environment E i , examples are drawn from the joint distribution P i ( x, y ) .
Following Woodward (2005), we deﬁne 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 classiﬁer will not rely on these spurious features.
Overview If the unstable features have been identiﬁed for the target task, we can simply apply group DRO to learn a stable classiﬁer.
By grouping examples based on the unstable features and minimizing the worst-case risk over these manually-deﬁned 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 classiﬁer 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 reﬂect the similarity of the examples in terms of their unstable features: among examples with the same label value, those that share the same prediction
[Table]
Contrasting and
S. S.
[Table]
S.
[Table] [Table]
[Table] [Table]
[Table] [Table]
=
=</latexit>
f Z .
- - - - - - -- - -- - - + + ++ +++++ + + + + - - - - - - - -- - - - - + + + + + + + + ++ + + +
T.
[Table]
<latexit sha1_
[Table]
="GpAr9+gRrG521GVsy5Vhd1G8hJs=">AAAB/XicbVDLSsNAFJ34rPUVHzs3g0VwVZIi6rLoxmUF+4AmhMl00g6dR5iZiDUUf8WNC0Xc+h/u/BunbRbaeuDC4Zx7ufeeOGVUG8/7dpaWV1bX1ksb5c2t7Z1dd2+/pWWmMGliyaTqxEgTRgVpGmoY6aSKIB4z0o6H1xO/fU+UplLcmVFKQo76giYUI2OlyD0MOBWBkIxyanSUwICjh8iteFVvCrhI/IJUQIFG5H4FPYkzToTBDGnd9b3UhDlShmJGxuUg0yRFeIj6pGupQJzoMJ9eP4YnVunBRCpbwsCp+nsiR1zrEY9tJ0dmoOe9ifif181MchnmVKSZIQLPFiUZg0bCSRSwRxXBho0sQVhReyvEA6QQNjawsg3Bn395kbRqVf+8Wrs9q9SvijhK4Agcg1PggwtQBzegAZoAg0fwDF7Bm/PkvDjvzsesdckpZg7AHzifP8GSlWw=</latexit> min f max - --- --- - <
[Equation]
L
[Equation]
L
[Equation]
[Table] [Table]
=</latexit>
L <latexit sha1_
[Table]
="cPDMCjK1xRlvrYx2pU6BOeFw/
[Table]
="
[Table]
AAAB8nicbVDLSgMxFL1TX7W+
[Table]
//oHp41NEyVYS2ieRS9UKsKWeCtg0znPYSRXEcctoNJ7e5332iSjMpHs00oUGMR4JFjGBjJb8fYzMmmGf3s0G15tbdOdAq8QpSgwKtQfWrP5QkjakwhGOtfc9NTJBhZRjhdFbpp5ommEzwiPqWChxTHWTzyDN0ZpUhiqSyTxg0V39vZDjWehqHdjKPqJe9XPzP81MTXQcZE0lqqCCLj6KUIyNRfj8aMkWJ4VNLMFHMZkVkjBUmxrZUsSV4yyevkk6j7l3WGw8XteZNUUcZTuAUzsGDK2jCHbSgDQQkPMMrvDnGeXHenY/FaMkpdo7hD5zPH4NPkWk=</latexit>
L ( ) - <latexit sha1_
[Table]
="
[Table]
+
[Table]
=
[Table]
AAAB
[Table]
=
=</
[Table]
> f Z <
[Table]
=
[Table]
=
[Table]
+HicbVDLSsNAFL2pr1ofjbp0M1gEVyUpoi6LblxWsA9sQ5lMJ
[Table]
[Table] [Table]
[Figure]
outcome have more similar unstable features than those with different predictions (Theorem 1).
We can then derive a representation f Z where examples are distributed based on the unstable features Z .
Next, we cluster target examples into groups based on the learned unstable feature representation f Z .
These automatically-derived groups correspond to different modes of the unstable features, and they act as proxies to the manually-deﬁned groups in the oracle setting where unstable features are explicitly annotated.
Finally, we use group DRO to obtain our robust target classiﬁer by minimizing the worst-case risk over these groups.
3. I NFERRING UNSTABLE FEATURES FROM THE SOURCE TASK
Given the data environments from the source task, we would like to 1) identify the unstable correlations across these environments; 2) learn a representation f Z ( x ) that encodes the unstable features
Z ( x ) .
We achieve the ﬁrst 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 E i and E j be two different data environments.
Bao et al.
(2021) shows that by training a classiﬁer
f i on E i and using it to make predictions on E j , we can reveal the unstable correlations from its prediction results.
Intuitively, if the unstable correlations are stronger in E i , the classiﬁer f i will overuse these correlations and make mistakes on E j when these stronger correlations do not hold.
In this work, we connect the prediction results directly to the unstable features.
We show that the prediction results of the classiﬁer f i on E j estimate the relative distance of the unstable features.
Theorem 1 (Simpliﬁed) .
Consider examples in E j with label value y .
Let X (cid:88) 1 , X (cid:88)
2 denote two batches of examples that f i 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
[Equation]
almost surely for large enough batch size.
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-speciﬁc 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 f Z ( 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:
[Equation]
where δ is a hyper-parameter.
By minimizing Eq equation 1, we encourage examples that have similar unstable features to be close in the representation f Z .
To summarize, inferring unstable features from the source task consists of three steps (Figure 2.S):
S.
For each source environment E i , train an environment-speciﬁc classiﬁer f i .
S.
For each pair of environments E i and E j , use classiﬁer f i to partition E j into two sets: E i (cid:88) j and E i × j , where E i (cid:88)
j contains examples that f i predicted correctly and E i × j contains those predicted incorrectly.
S.3 Learn an unstable feature representation f
Z
by minimizing Eq equation 1 across all pairs of environments
E i , E j and all possible label value y :
[Equation]
where batches X (cid:88) 1 , X (cid:88) 2 are sampled uniformly from E i (cid:88)
j | y and batch X × 3 is sampled uniformly from E i × j | y ( ·| y denotes the subset of · with label value y ).
3. L EARNING STABLE CORRELATIONS FOR THE TARGET TASK
Given the unstable feature representation f Z , our goal is to learn a target classiﬁer 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 f Z .
For each target label value y , we use the representation f Z 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-deﬁned groups when annotations of the unstable features are available.
By minimizing the worst-case risk across all clusters, we explicitly enforce the classiﬁer 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.
For each label value y , apply K-means ( l 2 distance) to cluster examples with label y in the feature space
f Z .
We use C y 1 , . . .
, C yn c to denote the resulting cluster assignment, where n c is a hyper-parameter.
T.2 Train the target classiﬁer f by minimizing the worst-case risk over all clusters:
[Equation]
where L ( C y i ) is the empirical risk on cluster C y i .
[Table]
E XPERIMENTAL SETUP 4. D ATASETS AND SETTINGS
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
[Table]
we consider multiple tasks and study the transfer between these tasks.
Speciﬁcally, for each task, we split its data into four environments: E train 1 , E train 2 , E val , E test , where spurious correlations vary across the two training environments E train 1 , E train 2 .
For the source task S , the model can access both of its training environments E train 1 ( S ) , E train 2 ( S ) .
For the target task T , the model only has access to one training environment E train 1 ( 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 E val follows the same distribution as the training data E train 1 .
Table 1 summarizes the level of the spurious correlations for different tasks.
Additional details can be found in Appendix C.1.
Natural environments We also consider a practical setting where environments are directly deﬁned 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 deﬁne two environments:
E 1 = { Young = 0 } and E 2 = { Young = 1 } .
In the source task, both environments are available.
In the target task, we only have access to environment E 1 during training and validation.
At test time, we evaluate the robustness of our target classiﬁer against other latent attributes.
Speciﬁcally, 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 =} .
Following Sagawa et al.
(2019), We report the worst-group accuracy and the average-group accuracy.
4. B ASELINES
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 classiﬁer on the target task from scratch by minimizing the average loss across all examples.
Note that this classiﬁer is independent of the source task.
Its performance reﬂects the deviation between the training distribution and the testing distribution of the target task.
[Table]
Transfer methods Since the source task contains multiple environments
[Table]
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 ﬁxed when learning the target classiﬁer.
FINETUNE : We update the feature extractor when training the target classiﬁer.
(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 classiﬁer’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 classiﬁer 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 classiﬁer together with a de-biased classiﬁer.
The biased classiﬁer ampliﬁes its bias by minimizing the generalized cross entropy loss.
The de-biased classiﬁer then up-weights examples that are mis-labeled by the biased classiﬁer during training.
M - ADA (Qiao et al., 2020):
We use a Wasserstein auto-encoder to generate adversarial examples.
The de-biased classiﬁer 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 deﬁne groups and train an oracle model.
For example, in task SEABIRD , this oracle model will minimize the worst-case
[Table]
MULTITASK 69.
AU T O - D E
B I A S EIIL 64.
GEORGE 74.
LFF 45.
M - ADA 64.
DG - MMLD 69.
TOFU 85.
[Figure]
more attributes.
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).
R ESULTS
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
For comparison, the TRIPLET baseline directly encourages source examples with the same label to stay close to each other in the feature space, from which we generate the clusters.
For both methods, we generate two clusters for each target label value and report the average performance across all label values.
We observe that the TRIPLET representation, while biased by the spurious correlations, fails to recover the ground truth unstable features for some tasks.
By explicitly contrasting the source environments, TOFU derives clusters that are highly-informative of the unstable features.
[Table]
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 f Z on MNIST EVEN .
Figure 3 demonstrates that while f Z 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 ﬁve different colors, it is impossible to recover the oracle groups.
However, TOFU still achieves almost perfect completeness.
C ONCLUSION
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-deﬁned 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 signiﬁcant performance gain.
Quantitative and qualitative analyses conﬁrm that our method is able to identify the hidden biases.
Due to space limitations, we leave further discussions to Appendix A.