Transfer Learning or Self-supervised Learning? A Tale of Two Pretraining Paradigms

Pretraining has become a standard technique in computer vision and natural language processing, which usually helps to improve performance substantially. Previously, the most dominant pretraining method is transfer learning (TL), which uses labeled data to learn a good representation network. Recently, a new pretraining approach -- self-supervised learning (SSL) -- has demonstrated promising results on a wide range of applications. SSL does not require annotated labels. It is purely conducted on input data by solving auxiliary tasks defined on the input data examples. The current reported results show that in certain applications, SSL outperforms TL and the other way around in other applications. There has not been a clear understanding on what properties of data and tasks render one approach outperforms the other. Without an informed guideline, ML researchers have to try both methods to find out which one is better empirically. It is usually time-consuming to do so. In this work, we aim to address this problem. We perform a comprehensive comparative study between SSL and TL regarding which one works better under different properties of data and tasks, including domain difference between source and target tasks, the amount of pretraining data, class imbalance in source data, and usage of target data for additional pretraining, etc. The insights distilled from our comparative studies can help ML researchers decide which method to use based on the properties of their applications.


Introduction
Pretraining is a commonly used technique in deep learning to learn more effective representations for alleviating overfitting. Given a target task where the amount of training data is limited, training deep neural networks on this small-sized dataset has high risk of overfitting. To address this problem, one can pretrain the feature extraction layers in the network on large-sized external data from some source tasks, then finetune these layers on the target data. The abundance of source data enables the network to learn powerful representations that are robust to overfitting. And such representation power can be leveraged to assist in the learning of the target task with more resilience to overfitting.
Arguably, the most popular pretraining approach is transfer learning (TL) [1], which learns the weight parameters of a representation network by solving a supervised source task, i.e., correctly mapping input data examples to their labels (e.g., classes, segmentation masks, etc.). While successful, one concern of TL is that it uses labels in the source task to learn network weights, which may be biased to the source labels and generalize less well on the target task where the classes in the target labels are different from those in the source task.
This problem can be potentially alleviated by unsupervised pretraining, which trains the network weights purely based on input data examples without using any labels in the source task. Recently, selfsupervised learning (SSL) [2,3], as an unsupervised pretraining approach, has achieved promising success and outperforms transfer learning in a wide range of applications [2]. Similar to TL, SSL also solves predictive tasks. But the output labels in SSL are constructed from the input data, rather than annotated by human as in TL. The auxiliary predictive tasks in SSL could be predicting whether two augmented data examples originate from the same original data example [3], inpainting masked regions in images [4], etc. Since SSL does not leverage labels provided by human, it does not have the risk of being biased to labels in a source task. On the other hand, the potential pitfall of not using human-annotated labels is that the learned representations by SSL may not be as discriminative as those in TL. In sum, conceptually, SSL and TL both have advantages and disadvantages. It is difficult to judge whether one is better than the other. The existing empirical results show that in certain tasks, SSL outperforms TL [2]; in other tasks, TL performs better than SSL [5]. But these studies did not provide a clear guidance on what properties of data and tasks render one approach works better than the other. Consequently, ML researchers are not informed about how to select the right pretraining method and they have to try both empirically to find out, which is time-consuming and resource-intensive.
To address this issue, we perform comprehensive studies to compare SSL and TL, and investigate which method works better under different properties of data and tasks, including domain difference between source and target tasks, the amount of pretraining data, class imbalance in source tasks, and the usage of target data for additional pretraining. The studies are performed on 5 source tasks and 4 target tasks from various domains including daily-life objects, general scenes, natural creatures, and medical imaging. We summarize the insights distilled from the comparative studies to help ML researchers decide which pretraining method to use based on the specific properties of their applications. The major insights obtained from the studies include: • When the domain difference between the source task and the target task is large, SSL outperforms TL. When domain difference is small, TL outperforms SSL. • On the same source task, when the amount of pretraining data is small, SSL outperforms TL. When the amount is large, TL outperforms SSL. • SSL is less sensitive to domain difference than TL: on the same target task, the performance of SSL pretrained on source tasks with varying domain difference with the target task is relatively stable while that of TL varies a lot. • When domain difference is small, SSL is less sensitive to the amount of pretraining data than TL: given a target task and a source task that have small domain difference, the performance of TL on the target task changes a lot under varying amount of pretraining data in the source task while SSL is relatively stable. • SSL is more robust to class imbalance compared with TL: pretrained on source datasets with varying ratios of class imbalance, the performance of SSL varies less than TL. • For SSL, using the training examples in the target task as additional pretraining data works better than using source data only, which is not the case for TL.

Transfer Learning and Self-supervised Learning
Representation learning network Input data in source task TL: Human-provided labels in source task

Pretraining
Representation learning network Prediction network in target task Input data in target task Human-provided labels in target task

Fine-tuning
Prediction network in source task SSL: Auto-generated labels from source data  and self-supervised learning (SSL). Both TL and SSL consist of two phrases: pretraining on source task and finetuning on target task. The purpose of pretraining is to train the weight parameters of a representation network into a good state. The pretrained weights are used to initialize the representation network in the target task (which has the same architecture as that in the source task). The initialized representation network in the target task is further trained on the target data. The difference between TL and SSL is that: TL performs pretraining using labeled source data in a supervised way while SSL performs pretraining using unlabeled source data in an unsupervised way.
Arguably, transfer learning [1] is the most widely used method for pretraining. Given data examples D T and their class labels L T in a target task T , a neural network N T is designed to fulfill this task. N T is composed of two parts: a feature extraction sub-network F T that learns latent feature representations of D T and a prediction sub-network P T which is tailored to the predictive task in T . Typically, the majority of weight parameters of N T lie in the feature extraction part F T . Meanwhile, one has access to data examples D S and their class labels L S in a source task S, where D S is in general much larger than D T . How transfer learning (TL) works is: it creates a network N S to solve the predictive task in S where the feature extraction sub-network F S has the same architecture as F T , but the prediction sub-network P S is tailored to task S. TL trains N S on D S and L S until convergence. Then it uses the weights of F S to initialize F T and trains N T on D T and L T until convergence. While TL has demonstrated pervasive effectiveness, there is a major concern about this approach. The weights in F S are trained by fitting the labels L S . Therefore they are naturally biased to the classes in L S . When applied to predicting a new set of classes in L T , this bias may render the prediction less accurate.
Recently, in parallel to transfer learning, another pretraining paradigm -self-supervised learning (SSL) [2,3] -has arisen much research interest. Different from TL which is typically conducted in a supervised manner (by labels in source tasks), SSL is undertaken mostly in an unsupervised way without using any human-provided labels. The basic idea of SSL is to construct some auxiliary tasks solely based on the input data itself without using any human-offered annotations and encourage the network to learn meaningful representations by performing the auxiliary tasks well. Given the source data D S , SSL designs an auxiliary task A and a network N A to perform this task. N A has a feature extraction sub-network F A that has the same architecture as F T and a prediction sub-network that is tailored to the task A. SSL trains N A on D S until convergence. Then it uses the weights of F A to initialize F T , then trains N T on D T and L T until convergence. Since SSL does not leverage labels in the source task, the learned feature extraction sub-network is not biased to these labels and is presumably more generalizable on D T . However, a potential downside is: F A is learned without human supervision, which renders the network less discriminative.

Contrastive self-supervised Learning
The auxiliary tasks in SSL can be constructed using many different mechanisms, such as rotation prediction [6], image inpainting [7], automatic colorization [8], context prediction [9], etc. Recently, a contrastive mechanism [10] has gained increasing attention and demonstrated promising results in several studies [2,3]. The basic idea of contrastive SSL is: generate augmented examples of original data examples, create a predictive task where the goal is to predict whether two augmented examples are from the same original data example, and learn the representation network by solving this task.
Different methods have been proposed to implement contrastive SSL. In SimCLR [3] designed for image data, given the input images, random data augmentation is applied to these images. If two augmented images are created from the same original image, they are labeled as being similar; otherwise, they are labeled as dissimilar. Then SimCLR learns a network to fit these similar/dissimilar binary labels. The network consists of two modules: a feature extraction module f (·) which extracts the latent representation h = f (x) of an image x and a multi-layer perceptron g(·) which takes h as input and generates another latent representation z = g(h) used for predicting whether two images are similar. Given a similar pair (x i , x j ) and a set of images {x k } that are dissimilar from x i , a contrastive loss can be defined as: where sim(·, ·) denotes cosine similarity between two vectors and τ is a temperature parameter. SimCLR learns the network weights by minimizing losses of this kind. After training, the feature extraction sub-network is used for downstream tasks and g(·) is discarded.
While SimCLR is easy to implement, it requires a large minibatch size to yield high performance, which is computationally prohibitive. MoCo [2] addresses this problem by using a queue that is independent of minibatch size. This queue contains a dynamic set of augmented data examples (called keys). In each iteration, the latest minibatch of examples are added into the queue; meanwhile, the oldest minibatch is removed from the queue. In this way, the queue is decoupled with minibatch size. The keys are encoded using a momentum encoder. Given an augmented data example in the current minibatch (called query) and a key in the queue, they are considered as a positive pair if they originate from the same image, and a negative pair if otherwise. A similarity score is calculated between the encoding of the query and the encoding of each key. Contrastive losses are defined on the similarity scores.

Design of Studies
In this section, we study several factors that may affect the comparative advantages between SSL and TL, including domain difference between source task and target task, the amount of pretraining data, class imbalance in source task, and usage of target data for additional pretraining.
Study of domain difference We use five source domains and four target domains, from the following areas: (1) objects in daily life, (2) scenes in daily life; (3) nature such as plants and animals, and (4) medical images such as CTs and X-rays. We use five source datasets: ImageNet, SUN, iNaturalist, LUNA, and ChestX-ray8, from objects, scenes, nature, CT, and X-ray domains respectively. The details of these five datasets are: • The ImageNet [11] dataset contains 1,281,167 training and 50,000 validation images from 1,000 classes. These classes cover common objects in daily life, such as monitor, school bus, sleeping bag, teapot, broccoli, etc.
• The SUN-397 [12] dataset contains 130,519 images from 397 scene categories, such as abbey, balcony, cafeteria, etc. Each category has more than 100 images.
We use four target datasets: Caltech-256, Flowers-102, COVID-CT, and Pneumonia from objects, nature, CT, and X-ray domains respectively. The detailed information of these datasets is as follows.
• The Caltech-256 [16] dataset contains 256 categories of objects in daily life, such as instruments, furniture, animals, food, vehicles, etc. The number of training, validation, and testing images is 7710, 6425, and 6425 respectively.
• The Flowers-102 [17] dataset contains 102 types of flowers. The number of training, validation, and testing images is 6149, 1020, and 1020 respectively.
• The Pneumonia [19] dataset contains 5,863 X-ray images which are either positive for pneumonia or negative. The number of training, validation, and testing images are 5216, 16, and 624 respectively.
We perform a quantitative measurement of domain difference of two tasks on their visual contents and class labels. To measure visual distance between domains, we use the method in [20]. We sample 1000 images from a source task and label them as 0, and sample 1000 images from a target task and label them as 1. Then we split the 2000 images into a training set and a test set. We train a classifier on the training set to distinguish whether an image is from source or target, then measure the classification error on the test set. The visual difference is defined as d = 2(1 − 2 ). Intuitively, if source images and target images are easy to be told apart (i.e., is small), then their visual difference is large. In addition to visual difference, we also measure domain difference in the label space.
-----+ + + Figure 2: Source-target domain difference. Figure 2 shows the visual difference and class similarity between source and target tasks. If the visual distance is less than 1.6, a source and a target are considered as in the same domain (denoted by "+"); otherwise, in different domains (denoted by "-"). For class similarity, "+" if the similarity is greater than 0.6, and "-" if otherwise. The third panel in Figure 2 shows the results, where the first and second symbol in each cell correspond to visual distance and class similarity respectively. A source and a target with "++" have high domain similarity, and those with "--" have large domain differences. The results are in accordance with intuitive judgement. For example, ImageNet and Caltech-256 are in the same domain about daily objects; iNaturalist and Flowers-102 are in the same domain about nature.
Study of the amount of pretraining data To study how SSL and TL are affected by the amount of pretraining data, we perform the following controlled study: for each source dataset, we use 1%, 10%, and 100% of the dataset for pretraining.

Study of class imbalance in source tasks
In a source task with class labels, the frequencies of classes are typically imbalanced. We are interested in studying how class imbalance affects the performance of SSL and TL. From a source dataset, we create imbalanced datasets with different imbalance ratios, pretrain SSL and TL on these datasets, and check how their performance varies with the imbalance ratio. Given a source dataset containing K classes, we rank these classes in ascending order of their frequencies. Let n j denote the frequency of the j-th ranked class. The class imbalance ratio ρ is defined as n K /n 1 , which is the ratio between the number of training examples of the most and least frequent class. We create datasets with different imbalance ratios by tuning n K and n 1 . For the rest classes, we perform random sampling to ensure the frequencies of these classes form an arithmetic sequence: specifically, the frequency of class j is (j − 1) × (n K − n 1 )/(K − 1) + n 1 , for j = 2, · · · , K − 1.
Study of using target data for additional pretraining In existing approaches, pretraining is mostly conducted on source data. We are interested in investigating whether it is helpful to add the training examples in the target task as additional data for pretraining and how this will affect the comparative advantages of SSL and TL. We compare the following pretraining settings: (1) SSL on source data only, on target data only, and on the combined data of source and target; (2) TL on source data only, on target data only, and on the combined data of source and target. For SSL on target data only, we pretrain SSL on training images in the target task, then finetune using both input images and output labels in the target training set. For SSL on the combined data of source and target, we pretrain SSL on source images and target training images. For TL on target data only, it is the same as finetuning on the target task with random initialization of the network. For TL on the combined data, it is a multi-task learning problem which trains classification models for the source task and target task simultaneously.

Experimental settings
All source tasks and target tasks are about image classification. We used ResNet-50 [22] for classification. The architecture of ResNet-50 is the same for different tasks, except the number of output units (which is the same as the number of categories in a task). The TL and SSL models pretrained on the full ImageNet dataset were borrowed from [22] and [2]. The rest of the models were pretrained from scratch.
For TL on source tasks, we applied data augmentation including random resize with a ratio sampled from [0.08, 1], random crop of 224 × 224, and the ImageNet AutoAugment policy [23]. The weights were optimized using SGD with an initial learning rate of 0.1 and a momentum of 0.9. We pretrained TL for 200 epochs on every source task with a minibatch size of 128. The learning rate was reduced by 0.1 every 50 epochs.
For SSL on source tasks, we used the data augmentation methods in [24] and used SGD as the optimizer with an initial learning rate of 0.015 and a momentum of 0.9. We pretrained SSL for 200 epochs and a batch size of 128. The learning rate was adjusted using cosine learning rate scheduling.
For finetuning on target tasks, we utilized the same data augmentation methods as in TL pretraining. We used Adam [25] as the optimizer with an initial learning rate of 0.001. The finetuning was performed for 200 epochs on Caltech-256 and Flower-101, 100 epochs on COVID-CT, and 30 epochs on Pneumonia. Cosine scheduling with a period of 6 was used to adjust the learning rate. The implementation was based on PyTorch and the experiments were conducted on 8 Tesla V100 GPUs.

Results on domain difference
We perform controlled studies to investigate how domain difference between source and target tasks affects the performance of SSL and TL. To rule out the influence of the amount of pretraining data, we make the number of pretraining examples in all source tasks the same. This number is chosen to be 90,000. For a source dataset whose size is larger than 90,000, we randomly sample 90,000 data examples from this dataset.  Table 1 shows the results on domain difference. From this table, we make the following observations. On most source-target pairs with strong domain similarity ("++"), including (ImageNet, Caltech-256), (SUN, Caltech-256), (iNaturalist, Flowers-102), (ChestX-ray8, Pneumonia), TL achieves better accuracy than SSL. This shows that when the domain difference is small, TL is more effective than SSL. The possible reason is: when the domain difference is small, the classes in source labels have a lot of overlap with those in target labels. Due to this overlap, it is beneficial to transfer the semantic information in source labels to the target task. TL utilizes sources labels while SSL does not. Hence TL works better than SSL. The only exception is (LUNA, COVID-CT), where TL performs worse than SSL. Second, on source-target pairs where the domain difference is large ("--"), including (ImageNet, COVID-CT), (ImageNet, Pneumonia), (SUN, Flowers-102), (SUN, COVID-CT), (SUN, Pneumonia), (iNaturalist, COVID-CT), (iNaturalist, Pneumonia), (LUNA, Caltech-256), (LUNA, Flowers-102), (ChestX-ray8, Caltech-256), (ChestX-ray8, Flowers-102), SSL achieves better accuracy than TL. This shows that when domain difference is large, SSL works better than TL. The possible reason is: when the domain difference is large, the classes in source labels are largely different from those in target labels. When the representations are learned by fitting source labels, they are biased to source classes and generalize less well on the target task which has a different set of classes. SSL avoids using source labels, hence is not prone to such a bias. Third, SSL is less sensitive to domain difference than TL. For example, on Caltech-256, the performance of SSL is relatively stable. The difference between the highest and lowest performance is about 4% (absolute). In contrast, for TL, the difference between the highest and lowest performance is about 15% (absolute). This is because TL uses source labels for pretraining. When the domain difference varies substantially, the labels change substantially, which makes the learned representations vary a lot. Fourth, on the same target domain, the closer a source domain is to this target, the better the performance is, for both SSL and TL. For example, in terms of domain similarity with Caltech-256, we have the following order: ImageNet, SUN > iNaturalist > LUNA, ChestX-ray8. As can be seen, the accuracy corresponding to these source domains decreases in general. This is because pretraining on a closer source domain can make the learned representations more suitable for the target domain.

Results on the amount of pretraining data
We evaluate the effect of the amount of pretraining data by pretraining SSL and TL on different subsets of each source dataset. Given a source dataset, we create two subsets by randomly sampling 1% and 10% of data examples. The experimental results are shown in Table 2. From this table, we make the following observations. First, when the amount of training data is small, SSL outperforms TL. For example, pretrained on 1% ImageNet, SSL outperforms TL on all target tasks. One possible reason is: when the training data is small, TL has a risk of overfitting to the labels of the small dataset and generalizes less well on target tasks. In contrast, SSL is an unsupervised pretraining method, which does not have the risk of overfitting to labels of small-sized source data. Second, when the amount of pretraining data is large, TL outperforms SSL. For example, pretrained on 100% ImageNet data, TL achieves better performance than SSL on all target tasks. The possible reason is: when the dataset is large, TL is less likely to suffer overfitting. On the contrary, the diverse labels contained in the large dataset enables TL to learn discriminative representations. Third, when domain difference is small, SSL is less sensitive to data amount than TL. For example, when the pretraining ImageNet data increases from 1% to 100%, the relative improvement of SSL on Caltech-256 is about 30% whereas the relative improvement of TL is about 62%. Fourth, for both SSL and TL, increasing the amount of training data leads to better performance. This is not surprising since deep learning methods are data hungry. Fifth, when the pretraining data is small, the performance of SSL and TL may be worse than random initialization. This is because SSL and TL may be overfitted to the small-sized pretraining data and generalize less well on the target tasks.  From ImageNet, we create 3 imbalanced datasets, with imbalance ratio ρ = 1, 5, 25, respectively. For ρ = 1, we set n 1 = n N = 130; for ρ = 5, n 1 = 43, n N = 215; for ρ = 25, n 1 = 10, n N = 250. Such settings ensure the total number of data examples in each dataset to be approximately the same (≈ 13, 000), so that the factor of pretraining data size can be ruled out. Figure 3 shows the results under different class imbalance ratios. From this table, we make the following observations. First, as the imbalance ratio increases, the performance of both SSL and TL decreases. The reason is that class imbalance renders the learned representations biased to images from frequent classes in the source task. The more imbalanced the classes are, the larger the bias is. A larger bias leads to worse generalization to target tasks. Second, SSL is more robust to class imbalance than TL. For example, on the COVID-CT task, the gap between the best and worst performance of SSL under different imbalance ratios is about 4.3% (absolute) while the gap for TL is about 6.5% (absolute). Similar results are observed on other target tasks as well. The reason is: TL is pretrained using class labels and therefore is more sensitive to the distribution of labels, including imbalance ratio. In contrast, the pretraining of SSL is label-free, hence is less affected by label distribution.  Figure 4: Results on the usage of target data for additional pretraining.

Results on using target data for pretraining
In this study, we compare the following pretraining settings: on source data only, on target data only, and on the combined data of source and target. The source dataset is SUN and target data refers to the data examples in the training set of a target task. Figure 4 shows the results. From this table, we make the following observations. First, for SSL, pretraining on the combined data performs better than on source-only and on target-only. The possible reason is: combined data has more training examples, which helps to learn better representations. Second, TL on the combined data performs better than on target-only. The reason is that performing TL on the combined data effectively leverages the source task to help with the learning of the target task via multi-task learning. Third, TL on the combined data performs worse than on source-only. The reason is: TL on source-only first pretrains on source data, then finetunes on target data. The focus is finetuning on target tasks, where the network is learned to best fit the target data. For TL on the combined data, training on source task and target task is performed simultaneously. The network aims to perform both tasks well instead of focusing on the target task. The reduced focus incurs worse performance on target tasks.

Related Works
Several works conducted preliminary comparisons of SSL and TL. In [2], supervised transfer learning (TL) is compared with an SSL approach -MoCo. It is shown that in certain tasks SSL outperforms TL, but the other way around in other tasks. It is not studied what factors incur such inconsistent results, which renders ML researchers have to try both approaches to find out which one works better empirically without an informed guidance. We aim to bridge this gap in our work, by systematically investigating under what situations SSL performs better than TL and vice versa. Zhai et al. [26] compared a number of representation learning methods, including supervised TL and SSL. They compared SSL and TL in terms of a single factor: image style. In our work, we perform a comprehensive comparison of SSL and TL on a number of factors. Newell and Deng [27] studied what factors affect the performance of SSL. The studies are performed on SSL only, rather than on the comparison with TL. Resnick et al. [28] performed a detailed study of SSL and presented several findings such as linear probes is insufficient to evaluate the representations learned by SSL, the bias towards success stemming from the architecture is high, etc. The study is mostly focused on SSL, instead of comparing with TL. Our work differs from these two in that our goal is to study what factors affect the comparative advantages between TL and SSL.

Conclusions
In this work, we make a comprehensive comparative study about SSL and TL, regarding which method works better under different properties of data and tasks. Specifically, we study how the domain difference between source and target tasks, the amount of pretraining data, class imbalance in source tasks, and the usage of target data for additional pretraining affect the comparative advantages of SSL and TL. On 5 source tasks and 4 target tasks from various domains, on varying amount of pretraining data, we conduct experiments and distill a set of insights. These insights can potentially help ML researchers to decide which pretraining method to use based on the properties of their applications and foster the development of new SSL and TL methods.