Agile Domain Adaptation

TL;DR

This paper introduces agile domain adaptation, a method that dynamically applies different levels of processing to target samples based on their adaptation difficulty, balancing accuracy and speed for real-time applications.

Contribution

It proposes a novel paradigm that performs early detection and classification, reducing computational cost while maintaining high accuracy in domain adaptation tasks.

Findings

Significantly reduces running cost of domain adaptation methods.

Maintains high accuracy with early exit strategy.

Effective on benchmark datasets.

Abstract

Domain adaptation investigates the problem of leveraging knowledge from a well-labeled source domain to an unlabeled target domain, where the two domains are drawn from different data distributions. Because of the distribution shifts, different target samples have distinct degrees of difficulty in adaptation. However, existing domain adaptation approaches overwhelmingly neglect the degrees of difficulty and deploy exactly the same framework for all of the target samples. Generally, a simple or shadow framework is fast but rough. A sophisticated or deep framework, on the contrary, is accurate but slow. In this paper, we aim to challenge the fundamental contradiction between the accuracy and speed in domain adaptation tasks. We propose a novel approach, named {\it agile domain adaptation}, which agilely applies optimal frameworks to different target samples and classifies the target samples according to their adaptation difficulties. Specifically, we propose a paradigm which performs several early detections before the final classification. If a sample can be classified at one of the early stage with enough confidence, the sample would exit without the subsequent processes. Notably, the proposed method can significantly reduce the running cost of domain adaptation approaches, which can extend the application scenarios of domain adaptation to even mobile devices and real-time systems. Extensive experiments on two open benchmarks verify the effectiveness and efficiency of the proposed method.

Figures

Tables

Algorithm 1. Agile Domain Adaptation Networks

Training

Learning the network parameters by optimizing Eq. (3).

Test

$ϵ=1$;                   %Initialize the network exit index

while

$𝐳$=$f_{{\mathrm{exit}}_{ϵ}}\left(𝐱\right)$;         %Get the features from exitϵ

$𝐲=\mathrm{softmax}\left(𝐳\right)$;    % Predict the label at exitϵ

$e=\mathrm{En}\left(𝐲\right)$;             %Calculate the sample entropy

if $e\le T_{ϵ}$             %If the entropy is lower than a threshold

return $𝐲$;          %Return the predicted label and finish

$ϵ=ϵ+1$;            %Otherwise, go to next exit

Until $ϵ>m$;

return $𝐲$;

Table 2. Table 1: Results (accuracy %) of digits recognition on MNIST and USPS datasets with LeNet-5.

Method	MNIST$\to$USPS
Source Only	78.9
BranchyNet (Teerapittayanon et al. 2106)	79.6
DAN (?)	81.1
CORAL (?)	81.7
DANN (?)	85.1
ADAN (Ours)	91.3

Table 3. Table 2: Our results of MNIST → → \rightarrow USPS with different thresholds, in which Acc. is the overall accuracy, time is the running time and ratio is the ratio of exited target samples via the first earlier exit.

Threshold	Acc.(%)	Time (ms)	Ratio (%)	Speedup
-Baseline-	91.27	2.42	0	1x
0.005	91.56	2.08	16.09	1.16x
0.010	91.56	1.91	19.02	1.27x
0.025	91.57	1.33	34.81	1.81x
0.050	91.60	1.14	47.27	2.12x
0.100	91.62	1.03	57.35	2.35x
0.250	91.62	0.83	69.31	2.92x
0.750	90.06	0.74	86.12	3.29x
1.500	87.55	0.44	99.50	5.52x

Table 4. Table 3: Results (accuracy %) of object classification on Office-31 dataset with ResNet.

Method	A$\to$D	A$\to$W	D$\to$A	D$\to$W	W$\to$A	W$\to$D	Average
ResNet	$68.9\pm 0.2$	$68.4\pm 0.2$	$62.5\pm 0.3$	$96.7\pm 0.1$	$60.7\pm 0.3$	$99.3\pm 0.1$	$76.1\pm 0.2$
TCA	$74.1\pm 0.0$	$72.7\pm 0.0$	$61.7\pm 0.0$	$96.7\pm 0.0$	$60.9\pm 0.0$	$99.6\pm 0.0$	$77.6\pm 0.0$
GFK	$74.5\pm 0.0$	$72.8\pm 0.0$	$63.4\pm 0.0$	$95.0\pm 0.0$	$61.0\pm 0.0$	$98.2\pm 0.0$	$77.5\pm 0.0$
DDC	$76.5\pm 0.3$	$75.6\pm 0.2$	$62.2\pm 0.4$	$96.0\pm 0.2$	$61.5\pm 0.5$	$98.2\pm 0.1$	$78.3\pm 0.3$
DAN	$78.6\pm 0.2$	$80.5\pm 0.4$	$63.6\pm 0.3$	$97.1\pm 0.2$	$62.8\pm 0.2$	$99.6\pm 0.1$	$80.4\pm 0.2$
RevGrad	$79.7\pm 0.4$	$82.0\pm 0.4$	$68.2\pm 0.4$	$96.9\pm 0.2$	$67.4\pm 0.5$	$99.1\pm 0.1$	$82.2\pm 0.3$
JAN	$84.7\pm 0.3$	$85.4\pm 0.3$	$68.6\pm 0.3$	$97.4\pm 0.2$	$70.0\pm 0.4$	$99.8\pm 0.2$	$84.3\pm 0.2$
Ours	$85.8\pm 0.3$	$88.8\pm 0.4$	$69.8\pm 0.3$	$97.4\pm 0.2$	$70.6\pm 0.3$	$99.4\pm 0.4$	$85.3\pm 0.3$

Table 5. Table 4: Our results of object classification on Office-31 dataset with different thresholds, in which threshold a/b denotes a% and b% samples are exited via the first earlier exit and the second earlier exit, respectively. The remainder, i.e., (100-a-b)%, is processed by the final exit.

Evaluation	W$\to$D		D$\to$W
Threshold	Acc.(%)	Speedup	Acc.(%)	Speedup
-Baseline-	99.39	1.0x	97.36	1.0x
10/50	98.74	1.73x	96.69	1.32x
10/60	98.54	1.82x	96.63	1.31x
10/70	98.59	2.17x	96.32	1.36x
20/50	97.99	1.63x	94.27	1.34x
20/60	97.23	2.52x	94.49	1.35x
30/40	96.33	2.03x	91.88	1.36x
30/50	94.72	1.99x	90.47	1.22x
40/50	91.86	1.71x	89.05	1.24x
50/20	88.95	1.74x	85.60	1.21x
50/30	87.04	2.37x	84.43	1.20x

Equations

$$\begin{array}[]{c}\mathcal{L}_{\mathrm{sup}}=\frac{1}{n_{s}}\sum\limits_{i=1}^{n_{s}}J(f(\mathbf{x}_{s,i}),\mathbf{y}_{s,i}),\end{array}$$

$$\begin{array}[]{c}\mathcal{L}_{\mathrm{exit}_{\epsilon}}=\mathcal{L}_{\mathrm{sup}}+\lambda\mathcal{L}_{\mathrm{tran}},\end{array}$$

$$\begin{array}[]{c}\mathcal{L}=\sum\limits_{\epsilon=1}^{m}w_{\epsilon}\mathcal{L}_{\mathrm{exit}_{\epsilon}},\end{array}$$

$$\begin{array}[]{c}J(\hat{\mathbf{y}},{\mathbf{y}})=-\frac{1}{|C|}\sum\limits_{c\in C}y_{c}\mathrm{log}\hat{y}_{c},\end{array}$$

$$\begin{array}[]{c}\hat{\mathbf{y}}=\mathrm{softmax}(f({\mathbf{x}}))=\dfrac{\mathrm{exp}(f({\mathbf{x}}))}{\sum\limits_{c\in C}\mathrm{exp}(f({\mathbf{x}})_{c})}.\end{array}$$

$$\begin{array}[]{c}\mathrm{MMD}(\mathbf{X}_{s},\mathbf{X}_{t})=\frac{1}{n_{s}^{2}}\sum\limits_{i=1}^{n_{s}}\sum\limits_{j=1}^{n_{s}}k(\mathbf{x}_{s,i},\mathbf{x}_{s,j})\\ ~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}-\frac{2}{n_{s}n_{t}}\sum\limits_{i=1}^{n_{s}}\sum\limits_{j=1}^{n_{t}}k(\mathbf{x}_{s,i},\mathbf{x}_{t,j})\\ ~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}+\frac{1}{n_{t}^{2}}\sum\limits_{i=1}^{n_{s}}\sum\limits_{j=1}^{n_{s}}k(\mathbf{x}_{t,i},\mathbf{x}_{t,j}),\end{array}$$

$$\begin{array}[]{c}\mathcal{L}_{\mathrm{tran}}=\frac{1}{n_{s}^{2}}\sum\limits_{i=1}^{n_{s}}\sum\limits_{j=1}^{n_{s}}\prod\limits_{l=1}^{L}k^{l}(\mathbf{z}_{s,i}^{l},\mathbf{z}_{s,j}^{l})\\ ~{}~{}~{}~{}~{}~{}~{}~{}-\frac{2}{n_{s}n_{t}}\sum\limits_{i=1}^{n_{s}}\sum\limits_{j=1}^{n_{t}}\prod\limits_{l=1}^{L}k^{l}(\mathbf{z}_{s,i}^{l},\mathbf{z}_{t,j}^{l})\\ ~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}+\frac{1}{n_{t}^{2}}\sum\limits_{i=1}^{n_{s}}\sum\limits_{j=1}^{n_{s}}\prod\limits_{l=1}^{L}k^{l}(\mathbf{z}_{t,i}^{l},\mathbf{z}_{t,j}^{l}).\end{array}$$

$$\begin{array}[]{c}\mathcal{L}_{\mathrm{tran}}=\\ ~{}~{}\frac{2}{n_{s}}\sum\limits_{i=1}^{n_{s}/2}\Big{(}\prod\limits_{l=1}^{L}k^{l}(\mathbf{z}_{s,2i-1}^{l},\mathbf{z}_{s,2i}^{l})+\prod\limits_{l=1}^{L}k^{l}(\mathbf{z}_{t,2i-1}^{l},\mathbf{z}_{t,2i}^{l})\Big{)}\\ -\frac{2}{n_{s}}\sum\limits_{i=1}^{n_{s}/2}\Big{(}\prod\limits_{l=1}^{L}k^{l}(\mathbf{z}_{s,2i-1}^{l},\mathbf{z}_{t,2i}^{l})+\prod\limits_{l=1}^{L}k^{l}(\mathbf{z}_{t,2i-1}^{l},\mathbf{z}_{s,2i}^{l})\Big{)}.\end{array}$$

$$\begin{array}[]{c}\mathrm{En}({\mathbf{y}})=-\sum\limits_{c\in C}y_{c}\mathrm{log}y_{c},\end{array}$$

Full text

Introduction

Conventional machine learning algorithms generally assume that the training set and the test set are drawn from the same data distribution (?). The assumption, however, cannot always be guaranteed in real-world applications (?; ?). To address this, domain adaptation (?; ?; ?; ?) has been proposed to mitigate the data distribution shifts among different domains.

Existing domain adaptation approaches can be roughly grouped into traditional methods and deep learning methods. Traditional methods (?; ?; ?) generally do not care how to extract sample features. They only focus on the transfer techniques, such as distribution alignment (?), feature augmentation (?) and landmark selection (?). Deep learning methods (?; ?; ?) take care of both feature extraction and knowledge adaptation via an end-to-end architecture. Yet, no matter what learning paradigm they take, previous domain adaptation methods deploy exactly the same leaning framework for all of the target samples. Specifically, all of the target samples, both easy and hard, are processed via exactly the same pipeline, e.g., the same optimization steps in tradition learning and the same neural network layers in deep learning. Existing methods just feed all the samples into a general formulation which can output an average result. They neglect the inherent degrees of difficulty (as shown in Fig. 1) with the target samples.

In general, a simple or shadow framework is fast but rough. A sophisticated or deep framework, on the contrary, is accurate but slow. It is worth noting that a network shared by both easy and hard samples tends to get deeper and larger since the model has to handle hard samples. For a better understanding, thinking about a smart phone. Although one mostly uses the phone for calls and messages, it has to be powerful enough just in case one wants to play the Temple Run from time to time. As a result, the neglect of different adaptation difficulties makes the domain adaptation methods hard to be deployed in real-time and energy-sensitive applications. Fig. 1 has clearly shown that different adaptation difficulties do exist in real-world datasets. Intuitively, if the two domains are highly related, most of the target samples would be easy ones and hard samples tend to be less frequent. Otherwise, one should consider choosing a different source domain for adaptation. Since easy samples can be adapted by a simple or shadow framework and hard samples need more effort, so, why don’t we finish the easy ones first with almost no effort and then fully focus on hard ones?

Motivated by the above observations, we propose a novel domain adaptation paradigm which takes the degrees of classification difficulty into consideration. Specifically, we present a deep domain adaptation architecture which has multiple exits. Different exits are located after different layers along the backbone deep network. A common sense about deep neural network is that the features extracted from earlier layers are more general but coarse, while the features extracted from the latter layers are more fine but specific (?). Therefore, the most easy samples are supposed to be classified by very few layers with coarse features, and then these samples can be finished via the first exit. Similarly, the medium hard samples can be handled by the second exit, third exit and so on. At last, the very hard samples are handled by the final exit.

Since deep learning is computing-intensive, more layers generally need more computing power, e.g., GPU, memory and electricity. The early exit paradigm can significantly reduce the computational costs. As a result, it is possible to deploy our solution on a distributed platform. For instance, the first exit can be deployed on edge device, e.g., mobile devices. The second exit on local servers and the final exit on cloud. In particular, we can agilely tailor the deep architecture according to the specific application scenarios. At last, the main contributions of this paper can be listed as follows:

We propose a novel learning paradigm for domain adaptation. It explicitly handles the degrees of adaptation difficulty by introducing multiple exits in the learning pipeline. The proposed paradigm can be easily incorporated into deep domain adaptation approaches and significantly reduce their computational costs. 2. 2)

We present a novel domain adaptation method, i.e., agile domain adaptation networks (ADAN), which puts the learning paradigm into practice. Extensive experiments on open benchmarks verify the effectiveness and efficiency of ADAN. 3. 3)

For deep transfer learning methods, it is confusing to choose how many layers should be used to extract features. The earlier layers are more transferable but the corresponding features are too coarse. On the contrary, the features extracted from the latter layers are more fine/distinctive but these layers tend to be task-specific and hard to be transfered. In our approach, we find a way out of the dilemma. Specifically, earlier layers are used to classify easy samples and latter layers to classify hard ones. Our formulation takes full advantages from both the early layers and the latter layers. It is a practical way to challenge the fundamental contradiction between the accuracy and speed in domain adaptation tasks.

The remainder of this paper is organized as follows. Section II briefly reviews related work and highlights the merits of our approach. Section III details the proposed learning paradigm and corresponding approach ADAN. Section IV reports the experiments and analyzes ADAN. At last, section V is the conclusion and future work.

Related Work

A typical domain adaptation (?; ?; ?; ?) problem consists of two domains: a well-labeled source domain and an unlabeled target domain. The two domains generally have the same label space but different data distributions (?). Domain adaptation aims to mitigate the gap between the two data distributions, so that the knowledge, e.g., features and parameters, learned from the source domain can be transfered to the target domain. Recently, domain adaptation has been successfully applied to many real-world applications, such as image recognition (?; ?), multimedia analysis (?; ?) and recommender systems (?; ?).

Since domain adaptation aims to mitigate the distribution gap between the source domain and the target domain, it is vital to find a metric which can measure the data distribution divergence. Maximum mean discrepancy (MMD) (?) is widely considered as a favorable criteria in previous work. For instance, deep adaptation networks (DAN) (?) generalizes deep convolutional neural networks to the domain adaptation scenario. In DAN, the general (task-invariant) layers are shared by the two domains and the task-specific layers are adapted by multi-kernel MMD. Furthermore, joint adaptation networks (JAN) (?) extends DAN by aligning the joint distributions of multiple domain-specific layers across domains based on a joint maximum mean discrepancy (JMMD) criterion.

Recently, generative adversarial networks (GAN) (?) has been introduced into domain adaptation. Compared with the distribution alignment methods, adversarial domain adaptation models (?; ?) are able to generate domain invariant features under the supervision of a discriminator. For instance, adversarial discriminative domain adaptation (ADDA) (?) combines discriminative analysis, untied weight sharing and a GAN loss under a generalized framework. Coupled generative adversarial networks (CoGAN) (?) minimize the domain shifts by simultaneously training two GANs to handle the source domain and the target domain.

No matter MMD loss or GAN loss or both of them are used in domain adaptation networks, every target sample is handled by the same pipeline in previous methods. Different target samples generally have varying visual characteristics even if they are from the same category (as shown in Fig. 1). It is so straightforward that everyone can imagine that some target samples are closer to source samples and some target samples are far away (?). Intuitively, the closed samples are easier to be adapted than distant ones. Therefore, we advocate different pipelines for different samples. Specifically, simpler networks for easy and frequent samples, more complex networks for hard and rare ones. From the perspective of network structure, BranchyNet (?) and hard-aware deeply cascaded embedding (HDC) (?) are related with our work. BranchyNet leverages the insight that many test samples can be correctly classified early and therefore do not need the later network layers. HDC ensembles a set of models with different complexities in cascaded manner to mine hard examples at multiple levels. However, both BranchyNet and HDC are conventional machine learning approaches. They are limited to scenarios where the training set and the test set are drawn from the same data distribution. In transfer learning tasks, we have to address the distribution gaps along the network layers and exits.

Agile Domain Adaptation

Notations and Definitions

In this paper, we use a bold uppercase letter and a bold lowercase letter to denote a matrix and a vector, respectively. Subscripts $s$ and $t$ are used to indicate the source domain and the target domain, respectively. We investigate the unsupervised domain adaptation problem defined as follows.

Definition 1 *A domain $\mathbb{D}$ consists of three parts: feature space $\mathcal{X}$, its probability distribution $P(\mathbf{X})$ and a label set $\mathcal{Y}$, where $\mathbf{X}~{}\in~{}\mathcal{X}$. *

Problem 1 *Given a labeled source domain $\mathbb{D}_{s}$ and an unlabeled target domain $\mathbb{D}_{t}$, unsupervised domain adaptation handles the problem of transferring knowledge, e.g., samples, features and parameters, from $\mathbb{D}_{s}$ to $\mathbb{D}_{t}$, where $\mathbb{D}_{s}\!\neq\!\mathbb{D}_{t}$, $\mathcal{Y}_{s}\!=\!\mathcal{Y}_{t}$, $P(\mathbf{X}_{s})\!\neq\!P(\mathbf{X}_{t})$ and $P(\mathbf{y}_{s}|\mathbf{X}_{s})\!\neq\!P(\mathbf{y}_{t}|\mathbf{X}_{t})$. *

Overall Idea

In unsupervised domain adaptation, we have a labeled source domain $\{\mathbf{X}_{s},\mathbf{y}_{s}\}$ with $n_{s}$ samples and an unlabeled target domain ${\mathbf{X}_{t}}$ with $n_{t}$ samples. Our goal is to train a deep neural network $f(\mathbf{x})$ which has multiple exits, e.g., exit1, exit2, …, exitm. In the learned deep neural network, the very easy samples can be classified via the first exit, i.e., exit1, which is located after only a few early layers of the backbone network. In the same manner, more difficult samples are handled by subsequent exit2, …, exitm-1 until the last remaining samples are handled by the final exitm. At the testing stage, if samples come in one by one instead of in batches, the sample $\mathbf{x}$ would be first handled by exit1. If exit1 has enough confidence to classify $\mathbf{x}$, the testing would finish. Otherwise, $\mathbf{x}$ will be successively handled by the following exits until one of the exit has high confidence to classify it or finally handled by the last exit. The learning pipeline of this idea is shown in Fig. 2. It is worth noting that the number of exits and the structure of each exit can be tailored according to specific tasks.

Problem Formulation

Since we have the labels of $\mathbf{X}_{s}$, we can train the deep model on the source domain data in a supervised fashion. Specifically, the empirical error of $f(x)$ on $\mathbf{X}_{s}$ can be written as:

[TABLE]

where $J(\cdot)$ is a loss metric. Minimizing $\mathcal{L}_{\mathrm{sup}}$ can train a model which is suitable for the source domain. However, the model cannot handle the target domain due to the data distribution shift. Therefore, we further introduce domain adaptation layers into the network, so that the trained model can be applied for the target domain. In a deep neural network, e.g., AlexNet (?) and ResNet (?), deep features extracted from the earlier layers are more general and features from the latter layers tend towards specific (?). In other words, the features vary from domain-invariant to domain-specific along the network. Activations in the domain-specific layers are hard to be transferred. Consequently, we remold the domain-specific layers to domain adaptation layers by optimizing a transfer loss $\mathcal{L}_{\mathrm{tran}}$. As a result, the loss function of each exitϵ $(\epsilon=1,\cdots,m)$ which considers both the source domain and the target domain can be written as:

[TABLE]

where $\lambda>0$ is the balancing parameter, $\epsilon$ indicates the index of network exits.

In our agile domain adaptation networks, we have multiple exits, e.g., exit1, exit2, …, exitm. To train the whole ADAN in an end-to-end manner, we jointly optimize the loss functions of each exit. Formally, we optimize a weighted loss sum of $\mathcal{L}_{\mathrm{exit}_{\epsilon}}(\epsilon=1,2,\cdots,m)$:

[TABLE]

where $w_{\epsilon}>0~{}(\epsilon=1,2,\cdots,m)$ is the loss weight of exitϵ. In our paper, we simply set $w_{\epsilon}=1~{}(\epsilon=1,2,\cdots,m).$

In this paper, we deploy the cross-entropy loss for the labeled source data. If we use ${\mathbf{y}}$ to denote the one-hot ground-truth label vector of sample $\mathbf{x}$, $J(\cdot)$ can be written as:

[TABLE]

where $C$ is the set of all possible labels, $\hat{\mathbf{y}}$ is the predicted label vector of $\mathbf{x}$:

[TABLE]

For the transfer learning part $\mathcal{L}_{\mathrm{tran}}$, we deploy the multi-kernel MMD (?) loss as our metric. Specifically, given two data distributions of the source and the target domain, their MMD can be computed as the square distance between the empirical kernel means as:

[TABLE]

where $k(\cdot)$ is a kernel function which maps the data features into a reproducing kernel Hilbert space (RKHS). In this paper, we deploy the widely used Gaussian kernel.

Eq. (6) calculates the MMD on the original data feature $\mathbf{x}$. However, minimizing Eq. (6) is implicit in matching the activations generated by the domain adaptation layers. In transfer learning, the source activations and target activations generated by the domain adaptation layers are encouraged to be well-aligned so that the layer parameters can be shared by the two domains. Therefore, we explicitly minimize the MMD on layer activations (?). Let $\mathbf{Z}_{s}^{l}$ and $\mathbf{Z}_{t}^{l}$ denote the activations generated by layer $l$ from the source domain and the target domain, respectively, the MMD with respect to layer activations can be calculated by:

[TABLE]

Furthermore, Eq. (7) can be rewritten as the following equivalent form to reduce the computational costs (?).

[TABLE]

With Eq. (1) and Eq. (8), we can train our agile domain adaptation networks by optimizing the overall loss as shown in Eq. (3).

For the earlier detections, we need to estimate whether a sample should be finished at each exit. Therefore, we need a metric to measure the classification confidence. In this paper, we use the sample entropy as the metric, which is defined as:

[TABLE]

where $\mathbf{y}$ is a label vector which consists of the probabilities of all possible labels computed at each exit. From the physical meaning of entropy, we know that a lower entropy indicts a more certain output. As a result, we compare the sample entropy with a threshold in each exit. If the entropy is lower than the threshold, the classification of the sample would be finished. Otherwise, the sample will goto the next exit for prediction. For a better understanding, we show the main steps of our ADAN in Algorithm 1.

Experiments

In this section, we verify the proposed method with both accuracy and efficiency results. Two widely used base architectures, e.g., the classical LeNet (?) and the state-of-the-art ResNet (?), are tailored to work in the manner of agile domain adaptation. The source codes will be publicly available on our GitHub page.

Data Description

USPS and MNIST are two widely used datasets in domain adaptation. Both of them are comprised of images of handwritten digits. There are 9,298 and 70,000 samples in total in each dataset, respectively.

Office-31 dataset (?) consists of 4,652 samples from 31 categories. Samples in this dataset are from 3 subsets, e.g., Amazon (A), DSLR (D) and Webcam (W). Specifically, Amazon includes images downloaded from amazon.com. DSLR consists of samples captured by a digital SLR camera. Images in Webcam are shoot by a low-resolution web camera.

Implementation Details

Our proposed paradigm is independent from specific base architectures. It can be easily incorporated into any popular deep networks. Limited by space, we implement our ADAN based on two base architectures, e.g., LeNet (?) for digits recognition and ResNet (?) for object classification.

LeNet-5 contains three convolutional layers and two fully connected layers. In our ADAN, we add one earlier exit after the first convolutional layer. The earlier exit consists of a convolutional layer and a fully connected layer. For LeNet-5, we set batchsize as $128$, learning rate as $0.001$, optimizer as SGD with momentum $0.9$ and weight decay $0.0001$.

For ResNet-50, we add two earlier exits into the backbone network. The first one is located after the 3rd layer, and the second one after the 39th layer. One can also tailor the earlier exits, either numbers or locations, for their own applications. In our implementation, we provide a general template, which makes it embarrassingly simple to add, remove and modify the earlier exits. With respect to the training parameters, we set batchsize to $24$. We also use SGD with momentum of $0.9$ to optimize the objective function. The learning rate is adjusted during SGD using the same formula as reported in (?).

Metrics and Compared Methods

In the domain adaptation community, accuracy of the target domain is the most widely used metric. For the sake of fairness, we follow previous work (?; ?) and also report the accuracy of the target domain. Each of the reported results of our method is an average of $5$ runs. The results of compared method are cited from the original paper. Or, if not available in the original paper, we report the best results we can achieve by running their codes. All of the experiments settings are following the previous work (?; ?) to ensure fair comparison.

The following state-of-the-art methods are reported for comparison:

• •

TCA (?) and GFK (?) are two representative traditional domain adaptation methods. For fair comparison, deep features extracted from ResNet-50 are used as their raw inputs.

• •

LeNet-5 (?) and ResNet (?) are two baselines. BranchyNet (?) is a non-transfer method which deploys the similar idea with ours. By reporting BranchyNet as a baseline, we can see that transfer learning tasks need special care.

• •

CORAL (?), DANN (?), DDC (?), DAN (?) and JAN (?) are state-of-the-art deep domain adaptation approaches.

Quantitative Results

Table 1 and Table 2 report the experimental results of our method on MNIST and USPS datasets. Specifically, Table 1 verifies that our approach can achieve state-of-the-art accuracy. Table 2 further demonstrates that we can speed up the model THREE TIMES while the accuracy does not drop.

From the results in Table 2, several interesting observations can be drawn. At first, both the accuracy and the speed are improved by adding earlier exits. The backbone network achieves 91.27% in 2.42ms. With a earlier exit, however, ADAN can achieve 91.62% in only 0.83ms. In this case, 69.31% samples are finished by the earlier exit. Secondly, if we set a relatively big entropy threshold, e.g., 1.5, 99.5% samples can be handled by the earlier exit with 5.52 times speedup, while the accuracy only drops 3.72%. In real-world applications, we can deploy the earlier exit on mobile device and handle most of the cases with sufficient accuracy. At the same time, the complete backbone network can be deployed on the cloud to take care of hard samples. The last but not the least, since the features vary from domain-invariant to domain-specific along a deep network (?), features extracted from either earlier layers or latter layers have their cons and pros in transfer learning tasks. Our approach, notably, can take advantage from every layer and maximize the value of deep networks.

Table 3 and Table 4 show the results on Office-31 dataset. Similar to the results of digits recognition, we can observe that our approach achieves state-of-the-art performance and it can significantly reduce the running time by the earlier exits. Compared with the MNIST and USPS dataset, Office-31 is much more challenging. As a result, if the ratio of earlier exited samples goes high, the accuracy dropping is more obvious than in the digits recognition task. Notice that the baseline (backbone network) has 50 layers, while the first exit in our model is located after the 3rd layer, which is very shallow compared with ResNet-50. However, our model still get the accuracy of 97.23% compared with the baseline 99.8% on W$\rightarrow$D when we set 20% and 60% samples exit from the first earlier exit and the second earlier exit, respectively. Notably, with the sacrifice of 1.6% accuracy, we can speed up the model 2.52 times! The results on D$\rightarrow$W and other evaluations, e.g., A$\rightarrow$W and A$\rightarrow$D, draw the same conclusion. It is worth noting that Amazon is a very challenging dataset, the results on A$\rightarrow$W and A$\rightarrow$D, therefore, are not outstanding as the results on DSLR and Webcam. In our experiments, we tried that if we move the first exits backward several layers or if reduce the ratio of earlier detection, the results on A$\rightarrow$W and A$\rightarrow$D would improve. In our source code, we provide a general template to modify, add and remove earlier exits. One can tailor a personal ADAN with few lines of python codes.

Qualitative Results

Back to the Samples. The very basic motivation behind our formulation is that our approach handles the degrees of adaptation difficulty by introducing multiple earlier exits into the learning pipeline. To verify that our approach does perceive the adaptation difficulty and handle it with different strategies, we show some samples exited from different earlier exits in Fig. 4. From the results, it is crystal clear that our approach is able to identify the degrees of adaptation difficulty. For instance, let us take the last column, i.e., samples with the label monitor, on evaluation W$\rightarrow$D as an example. We can see that the samples exited via the first earlier exit are very similar with the source samples. These samples are easy to be adapted. The target samples exited from the second earlier exit are slightly different from the source samples in view point. At last, the samples exited from the final exit have distinctive capture angles with the source samples. These target samples are hard to be adapted. For the easy samples, we only use few layers to speed up the model. At the same time, for the hard samples, we deploy more deep networks to guarantee the accuracy. Our approach is agile and resilient.

Class-wise Visualization. Fig. 3 reports the visualized class-wise accuracy. Comparing the two lines of Fig. 3, it is clear that our approach is able to mitigate the distribution gaps between the source domain and the target domain.

Parameter Sensitivity. The main parameter in our model is $\lambda$ which balances the weight of supervised loss and transfer loss. Fig. 5(a) reports the effects of different $\lambda$ values. It can be seen that our model is not sensitive to the parameter when it chosen from [0,1]. However, the performance will degrade when $\lambda>2$. Since the model is targeted at leveraging knowledge from the source domain to facilitate the target domain, a large $\lambda$ would weaken the contribution of the source domain. The other hyper-parameter in our formulation is the weight $w_{i}$, we simply set it to one throughout this paper. We also tested it for different settings, and find $w_{i}$ is not sensitive to the overall performance.

Convergence. Fig. 5(a) reports the overall error with respect to different epochs. The results reflect the convergence of our approach. From the results we can observe that our approach is able to achieve the stable result around 20 epochs. It is worth noting that the reported results are from the evaluations with 10% and 50% samples exited via the first and second earlier exit, respectively. Thus, the results are slightly worse than the backbone network. However, the results report the overall convergence rather than only the backbone.

Ablation Analysis. Our approach consists of the backbone networks and the earlier exits. If we remove the exits and only remain the backbone, the performance of our approach would be similar with results reported in Table 3 and the baseline in Table 4. However, the running cost would be an issue for mobile devices and real-time systems.

Conclusion

In this paper, we propose a novel learning paradigm for domain adaptation. In the proposed paradigm, several earlier detections are performed to identify the adaptation difficulty. At the same time, several earlier exit are added along the backbone network to reduce the running cost. The proposed paradigm can be easily incorporated into existing deep domain adaptation networks or even non-transfer deep architectures, e.g., LeNet, AlexNet and ResNet.

In addition, a novel domain adaptation approach, i.e., agile domain adaptation networks (ADAN), is implemented to verify the effectiveness and efficiency of the proposed paradigm. Extensive experiment results, both quantitative and qualitative, show that our approach is able to achieve state-of-the-art accuracy and significantly reduce the running cost at the same time. In our future work, we will investigate the self-adapted ADAN which can automatically and dynamically adjust the earlier exits.