Auto-Transfer: Learning to Route Transferable Representations
Authors: Keerthiram Murugesan
Vijay Sadashivaiah
Ronny Luss
Karthikeyan Shanmugam
Pin-Yu Chen
Amit Dhurandhar
Venue: ICLR 2022 Poster (2022)
Keywords: Feature routing
Transferable Representations

Abstract: Knowledge transfer between heterogeneous source and target networks and tasks has received a lot of attention in recent times as large amounts of quality labeled data can be difficult to obtain in many applications. Existing approaches typically constrain the target deep neural network (DNN) feature representations to be close to the source DNNs feature representations, which can be limiting. We, in this paper, propose a novel adversarial multi-armed bandit approach that automatically learns to route source representations to appropriate target representations following which they are combined in meaningful ways to produce accurate target models. We see upwards of 5\% accuracy improvements compared with the state-of-the-art knowledge transfer methods on four benchmark (target) image datasets CUB200, Stanford Dogs, MIT67, and Stanford40 where the source dataset is ImageNet. We qualitatively analyze the goodness of our transfer scheme by showing individual examples of the important features focused on by our target network at different layers compared with the (closest) competitors. We also observe that our improvement over other methods is higher for smaller target datasets making it an effective tool for small data applications that may benefit from transfer learning.

Published as a conference paper at ICLR 2022
AUTO-TRANSFER LEARNING TO ROUTE TRANSFER- ABLE REPRESENTATIONS
Keerthiram Murugesan'
Vijay Sadashivaiah
Ronny Luss'
Karthikeyan Shanmugam'
Pin-Ye Yu Chen'
Amit Dhurandhar
IBM Research, Yorktown Heights
Rensselaer Polytechnic Institute, New york
keerthi ram. mawrugeaannimma com sadasv2@rpi .edu rluss@us. ibm. com karthikeyan, sharmugam20 1bm. com
pin-ya chen@ibm. com
adhuran@us ibm. com
ABSTRACT
Knowledge transfer between heterogeneous source and target networks and tasks has received lot of attention in recent times as large amounts of quality labelled data be difficult to obtain in many applications. Existing approaches typically constrain the target deep neural network (DNN) feature representations to be close the source DNNs feature representations, which can be limiting. We, in this paper, propose a novel adversarial multi-an aalti- bandit approach which automat- ically learns to route source representations to appropriate target representations following which they are combined in meaningful ways to produce accurate target models. We see upwards of 5% accuracy improvements compared with the state- of-the-art knowledge transfer methods on four benchmark (target) image datasets CUB200, Stanford Dogs, MIT67 and Stanford40 where the source dataset is Ima- geNet. We qualitatively analyze the goodness of our transfer scheme by showing individual examples of the important features our target network focuses on different layers compared with the (closest) competitors. We also observe that our improvement over other methods is higher for smaller target datasets making it an effective tool for small data applications that may benefit from transfer learning."
INTRODUCTION
Deep learning models have become increasingly good at learning from large amounts of labeled data. However, it is often difficult and expensive to collect sufficient a amount of labeled data for training a deep neural network (DNN). In such scenarios, transfer learning (Pan & Yang. 2009) has emerged as one of the promising learning paradigms that have demonstrated impressive gains in several domains such as vision, natural language, speech, etc., and tasks such as image classification (Sun et al., 2017; Mahajan et al., 2018), object detection (Girshick, 2015; Ren et al., 2015), segmentation (Long et al., 2015; He et al., 2017), question answering (Min al., 2017: Chung al., 2017), and machine translation (Zoph et al., 2016; Wang et al., 2018). Transfer learning utilizes the knowledge from information-rich source tasks to learn a specific (often information-pooy target task.
There are several ways to transfer knowledge from source task to target task (Pan & Yang, 2009), but the most widely used approach is fine-tuning (Sharif Razavian et al., 2014) where the target DNN being trained is initialized with the weights/representttioss of source (often large) DNN (c.g. ResNet (He et al., 2016)) that has been pre-trained on a large dataset (c.g. ImageNet (Deng al., 2009)). In spite of its popularity, fine-tuning may not be ideal when the source and target tasks/networks are heterogeneous i.e. differing feature spaces or distributions (Ryu et al., 2020; Tsai et al., 2020). Additionally, the pretrained source network can get overwritten//orgotter which prevents its usage for multiple target tasks simultaneously. Among the myriad of other transfer tech- niques, the most popular approach involves matching the features of the output (or gradient of the output) of the target model to that of the source model (Jang et al., 2019; Li et al., 2018; Zagoruyko & Komodakis, 2016). addition to the output features, a few methods attempt to match the features of intermediate states between the source and target models. Here, in this paper, we focus on the latter by guiding the target model with the intermediate source knowledge representations.
"Equal contribution, ordered alphabetically.
Code available https: : / /i thub. com/ http:///aaatotrrrsfffrrr

---

Published as a conference paper at ICLR 2022
Source Network ResNet34
ANNAB
ADDAB
ANAAB
AGcin
(9)
"Indigo Bunting"
Target Network ResNet18
conv1
Residual Block
Residual Block
Residual Block
Residual Block
Figure I: Illustration our proposed approach. During training, an input image is first forward passed through the source network (such as ResNet34 trained on ImageNet) and the internal feature representations are saved. An adversarial multi-ut armei bandit (AMAB). for each layer of the target network (such ResNet18), 18), selects the useful source features (if any) receive knowledge. Feature representations the next layer. this example the following (target, source) pairs are selected: (1,2), (2,1), (3,3), (4, None). Parameters for AMAB and combination modules are optimized over training data, At test time, given an input image, representations mapping best feature representation between source-target layers, based on our method, are combined for the target network to make decision.
then combined and fed into
While common approaches allow knowledge transfer between heterogeneous tasks/networks,, is also important recognize that constraining the target DNN representations be close certain source DNN representations may be sub-optimal. For example, a source model, trained to classify cats dogs may be accessed at different levels provide internal representations of tiger wolf images to guide the target task in classifying tigers vs wolves. Since the source model is trained with a large number of parameters and labeled examples of cats and dogs, will have learned several patterns that distinguish cat images from dog images. It is postulated that concepts or rep- resentations such as the shape the tail, eyes, mouth, whiskers, fur, etc. are useful differentiate them (Neyshabur al., 2020), and it is further possible reuse these learned patterns to generalize to new (related) tasks by accessing representations at the appropriate level. This example raises three important questions related to knowledge transfer between the source-targel models: 1) What knowledge to transfer? 2) Where to transfer? 3) How to transfer the source knowledge?
While the what and where have been considered in prior literature (Rosenbaum et al., 2018; Jang et al., 2019), our work takes a novel and principled approach to the questions what, where and how to transfer knowledge in the transfer learning paradigm. Specifically, and perhaps most impor- tantly, we address the question of how to transfer knowledge, going beyond the standard matching techniques, and take the perspective that might be best to let the target network decide what source knowledge is useful rather than overwriting one's knowledge to match the source representations. Figure 1 illustrates our approach to knowledge transfer where the question of what and where is addressed by an ad adversarial multi-armed bandit (routing function) and the how is addressed by an aggregation operation detailed later. In building towards these goals, we make the following contri- butions:
We propose transfer learning method that takes a novel and principled approach to automatically decide which source layers (if any) to receive knowledge from. To achieve this, we propose an adversarial multi-ammn armed bandit (AMAB) to learn the parameters of our routing function.
We propose to meaningfully combine feature representations received from the source network with the target that are considered, AMAB also plays a role in selecting the best one. This is in contrast with existing methods that force the target representation be similar to source representation.
feature representations, Among various aggregation operations
Benefits of the proposed method are demonstrated on multiple datasets. Significant improvements are observed over seven existing benchmark transfer learning methods, particularly when the target dataset is small. For example, in our experiment ImageNet-basee based transfer learning the target Stanford 40 Actions dataset, our auto-trane auto-transfer learning method achieved more than 15% improvement in accuracy over the best competitor.
2

---

Published as a conference paper at ICLR 2022
2 RELATED WORK
Transfer learning from a pretrained source model is a well-known approach to handle target tasks with a limited label setup. A key aspect of our work is that we seek to transfer knowledge between heterogeneous DNNs and tasks. Recent work focused on feature and network weight matching to address this problem where the target network is constrained to be near the source network weights and/or feature maps. Network matching based on SP regularization penalizes the &z distance of the pretrained source network weights and weights of the target networks to restrict the search space of the target model and thereby hinder the generalization (Xuhong et al., 2018). Recent work (Li et al., 2018) has shown that it is better to regularize feature maps of the outer layers than the network weights and reweighting the important feature via attention. Furthermore, distillation and selection (AFDS) matches the features of the output of the convolutional layers between the source- target models and prunes the unimportant features for computational efficiency. Similar matching can also be applied to match the Jacobians (change in output with respect to input rather than matching the output) between source and target networks (Srinivas & Fleuret, 2018). Previous works (Dhurandhar et al., 2018; 2020) also suggested that rather than matching the output of a complex model, could also be used to weight training examples of a smaller model.
inlention-basee feature
Learning without forgetting (LwF) (Li & Hoiem, 2017) leverages the concept of distillation (Hinton al., 2015) and takes it further by introducing the concept of stacking additional layers to the source network, retraining the new layers on the target task, and thus adapting to different source and target tasks. SpotTune (Guo et al., 2019) introduced an adaptive fine-tuning mechanism, where a policy network decides which parts of a network to freeze vs fine-tune. FitNet (Romero et al., 2014) introduced an alternative to fine-tuning, where the internal feature representations of teacher networks were used as guide to training the student network by using & matching loss between the two feature maps. Attention Transfer (AT) (Zagoruyko & Komodakis, 2016) used a similar approach to FitNet, except the matching loss was based attention maps. The most relevant comparison to our work is that of Learning to Transfer (L22T-wW) (Jang et al., 2019), which matches source and target feature maps but uses meta-learning based approach to learn weights for useful pairs of source-targer layers for feature transfer. Unlike L.2T-ww, our method uses a very different principled approach combine the feature maps in a meaningful way (instead of feature matching) and let the target network decide what source knowledge is useful rather than overwriting one's knowledge to match the source representations. Finally, Ji al. (2021) uses knowledge distillation based approach to transfer knowledge between source and target networks.
3 AUTO-TRANSFER METHOD
In this section, we describe our main algorithm for Auto-Transfer learning and explain in detail the adversarial bandit approach that dynamically chooses the best way to combine source and target representations in an online manner when the training of the target proceeds.
What is the best way to train a target network such that it leverages pre-trained source representa- tions speeding up training on the larget task in terms of sample and time efficiency? We propose routing framework to answer this: At every target layer, we propose to route one of the source repre- sentations from different layers and combine it with trainable operation (e.g. weighted addition) such that the composite function can be trained together (see Figure 10 for an example of combined representations). We propose use bandit algorithm make the routing/combination choices in an online manner, i.e. which source layer's 's representation to route to a given target layer and how combine, while the training of the target network proceeds. The bandit algorithm intervenes once every epoch of training to make choices using rewards from evaluation of the combined network on a hold out set, while the latest choice made by the bandit is used by the training algorithm to update the target network parameters on the target task. We empirically show the benefit of this approach with other baselines on standard benchmarks. We now describe this framework of source-target representation transfer along with the online algorithm.
3.1 ROUTING REPRESENTATIONS
For a given image x, let f2())) S (x)} and ..) .fM (x)) mediate feature representations for image from the source and the target networks, respectively.
be the inter-
3

---

Published as a conference paper at ICLR 2022
Let us assume the networks have trainable parameters Ws E R and Wy E R where d, and de are the total number of trainable parameters of the networks. Clearly, the representations are a function of the trainable parameters of the respective networks. We assume that the source network is pre-trained. These representations could be the output of the convolutional or residual blocks of the source and target networks.
Our Key Technique: For the i-th target representation fi. our proposed method a) maps to one of the N intermediate source representations, J'S. or NULL (zero valued) representation; b) uses T3, trainable transformation of the representation S'z. get fgg i.e. fz(()) Tj (z)(()))); and c) combines transformed source få and the target representations fī using another trainable operation 1.j be the set of trainable parameters associated with
+ chosen from set of operations M. Let W the operator chosen. We describe the various possible operations below. The target network uses the combined representation place of the original i-th target representation:
(+)) -(()(=,((f(()))) (x)
In the above equation, the trainable parameters of the operator depend on the i and j (that de- pendence is hidden for convenience in notation). The set of choices are discrete, that is, P [[N] U NULL] x .M where [N] denotes set of N source representations. Each choice has set of trainable parameters T3 w/ addition to the trainable parameters Wr the target network.
3.2 LEARNING THE CHOICE THROUGH ADVERSARIAL. BANDITS
To pick the source-target mapping and the operator choice, we propose an adversarial bandit-based online routing function (Auer et al., 2002) that picks one of the choices (with its own trainable parameters) containing information on what, where and how to transfer to the target representation Briefly, adversarial bandits choose actions az from a discrete choice of actions at time I, and the environment presents adversarial reward re(a;) for that choice. The bandit algorithm minimizes the regret with respect to the best action a" in hindsight. the knowledge transfer from the source model changes the best action (and the reward function) at every round as the target network adapts to this additional knowledge. This is the key reason to use adversarial bandits for making choices as it is agnostic to action dependent adversary.
our non-stationary problem setting,
Bandit Update: We provide our main update Algorithm for a given target representation from layer (f). At each round t, the update algorithm maintains probability vector over set of all possible actions from routing choice space P. The algorithm chooses a routing choice de = (je >> 4 ) randomly drawn according to the probability vector गe (in Line 7). Here je is the selected source representation to be transfered to the target layer and combined with target representation i using the operator D
Reward function: The reward It for the selected routing choice is then computed by evaluating gain in the loss due to the chosen source-target combination as follows: the prediction gain is the difference between the target network's losses on a hold out set D, with and without the routing choice a i.e., L (x)) C(jM (zr) for given image x from the hold out data. This is shown in the Algorithm 3 EVALUATE. The reward function used in Lines 4 and to update the probability vector Tp,t almost identical to the update in the classical EXP3, algorithm of (Auer et al., 2002). Note that if the current version of the trainable parameters is not available, then a random initialization is used. In experiments, this reward value is mapped to the [-1, range to feed as a reward to the bandit update algorithm.
Environment Update: Given the choice j + and the operator D the target network is trained for one epoch over all samples in the training data Dy for the target task. Algorithm 2 TRAIN- TARGET updates the target network weights Wr and other trainable parameters (W T2) of the routing choice a, for each epoch on the entire target training dataset. Our main goal is to train the best target network that effectively combine the best source representation chosen. Here, L is the loss function which operates on the final representation layer the target network. a, = 1/t and B is the exploration parameter. We set B = 0.4 and 7 10-3
4

---

12: end for Published as a conference paper at ICLR 2022
Algorithm AMAB Update Algorithm for Target Layer &
1: Inputs: Learning rate Exploration parameter B3, Number of Epochs E. Routing choice set
P
Initialize: Wo,ps f0,p f- 0.
2: for E [1: E] do
3: for do
4:
Wt.p f log [11 exp exp { (wi-1p + + +
at
Ejtp exp {wi-1s + 1
K-1
5:
e
B
Tep (1-3)
R
ewes
K
6:
end for
7:
Choose action Te. Let = (ir + f, +').
8: Obtain current version of trainable parameters: Tj. ('."")
Use the standard random
initialization if not initialized.
9: Te, EVALUATE(a,, (Wr,T), T,, w
(Wr J,, W TRAIN- TARGETT,,,GTTO, (Wr, Tze way))
p p- at: otherwise
Pt.
Algorithm 2 TRAIN-TARGET Train Target Network
1: Inputs: Target training dataset Dr. Target loss L(.). Routing choice: (j - θ)) Seed weight parameters: [0] T, [0]. w [0].
2: Randomly shuffle Dr.
3: for k [1: | do
4: x [k).
5: (W,, + (Wrkk-1],1) 1], w 11)
-9k V (WA:7WT5, C( (x))
6: end for
7: Output: Last iterate of (wr. Tj, w
Algorithm EVALUATE Evaluate Target Network
1: Inputs: Routing Choice: (j > i, D) Weight parameters: Wr, Tj, W Target task hold out set D,,-
Target Loss C()
2: Output: De
Σ L(MM (x)) C((
ZED.
3.3 ROUTING CHOICES
The routing choice (j + i, ① ..,g)) can be seen as deciding where, what and how to transfer/combine source representations with the target network.
Where to transfer? The routing function j i decides which one of the N intermediate source features is useful for a given target feature fi. In addition these combinations, we allow the routing function to ignore the transfer using the NULL option. This allows the target network to potentially discard the source knowledge if it's unrelated the target task.
What transfer? Once a pair of source-task (j + i) combination is selected, the routing func- tion decides what relevant information from the source feature f3 should be transferred the target
5

---

Published as a conference paper at ICLR 2022
network using the transformation T3. We use Convolution-BatchNoom block to transfer useful fea- tures to the target network f/- BN (Conv(fg)), Here, T; BB((Conv())). The convolution layer can select for relevant channels from the source representation and the batch normalization (loffe & Szegedy, 2015) addresses the covariant-shift between the source and the target representations, we believe that this combination is sufficient to "match" the two representations. This step also ensures that the source feature has similar shape to that of the target feature.
How to transfer (i.e. combine the representations)? Given pair of source and target feature repre- sentations (j + i), the routing function chooses one of the following operations (i.e. ( to combine them. We describe the class of operations M, i.c. the various ways (1) is implemented.
1. Identity (Iden) operation allows the target network just use the target representation fi after
looking at the processed source representation I's from the previous Conv-BN step.
2. Simple Addition (sAdd) adds the source and target features: f - f3 + f
Weighted Addition (w Add) modifies sAdd with weights for the source and target features. These
weights constitute W.y i.e. the trainable parameters of this operation choice: fi Wssi.
8/ + Wr.y ft.
4. Linear Combination (LinComb) uses the linear block (without bias term) along with the average
pooling weight the features: J4 L. f' + Linr,a (f+) S/ where Lin.,.. is linear transformation with its own trainable parameters.
5. Feature Matching (FM) follows the earlier work and forces the target feature to be similar the source feature. This operation adds regularization term w f fi-ll to the target objective L when we train.
Factorized Reduce (FactRed) use two convolution modules reduce the number of channels in the source and target features to c/2 and concat them together: f c/2 c/2 S.i.j (f$), (2,
Concat(Conv'a
An action from the search space is given by [(j + +) D.,l. The total number of choice combi- nations is O(N + 1)M). Typically N and M very small numbers, for instance, when Resnet is used as a source and target networks, we have N = 4, M = 5. For large action search spaces, action pruning (Even-Dar et al., 2006) and greedy approaches (Bayati et al., 2020) can be used to efficiently learn the best combinations as demonstrated in our experiment section.
4 EXPERIMENTS
In this section, we present experimental results to validate our Auto- Transfer methods. We first show the improvements in model accuracy that can be achieved over various baselines on six different datasets (section A.3) and two network/task setups. We then demonstrate superiority in limited sample size and limited training time usecases. Finally, we use visual explanations to offer insight as to why performance is improved using our transfer method. Experimental results toy example can be found in the supplement section A.
4.1 EXPERIMENTAL SETUP
Our transfer learning method is compared against existing baselines on two network/task setups. In the first setup, we transfer between similar architectures of different complexitie;; we use a la-le ResNet (He et al., 2016) as the source network pre-trained on ImageNet and an 18-layer ResNet as the target network. In the second setup, we transfer between two very different architectures; we use an 32-layer ResNet as the source network pretrained on TinyImageNet and a 9-layer VGG (Simonyan & Zisserman, 2014) as the target network. For ImageNet based transfer, we apply our method to four target tasks: Caltech-UCSD Bird 200 (Wah et al., 2011), MIT Indoor Scene Recogni- tion (Quattoni & Torralba, 2009). Stanford 40 Actions (Yao al., 2011 1) and Stanford Dogs (Khosla et al., 201 1). For TinyImageNet based transfer, we apply our method on two target tasks: CIFAR100 (Krizhevsky et al., 2009), STL-10 (Coates et al., 20.
We investigate different configurations of transfer between source and target networks. In the full configuration, an adverserial multi-armed bandit (AMAB) based on Exponential-weiggh algorithm

---

Published as a conference paper at ICLR 2022
for Exploration and Exploitation (EXP3) selects (source, target) layer pairs well as one of one of five aggregation operations to apply to each pair (operations are independently selected for each pair). In the route configuration, the AMAB selects layer pairs but the aggregation operation is fixed to be weighted addition. In the fixed configuration, transfer is done between manually selected pairs of source and target layers. Transfer can go between any layers, but the key is that the pairs manually selected. In each case, during training, the source network is passive and only shares the intermediate feature representation of input images hooked after each residual block. After pairs are decided, the target network does aggregation of each pair of source-targer representation in feed- forward fashion. The weight parameters of aggregation are trained to act as a proxy to how much source representation is useful for the target network/task. For aggregating features of different spatial sizes, we simply use bilinear interpolation.
4.2 EXPERIMENTS ON TRANSFER BETWEEN SIMILAR AND DIFFERENT ARCHITECTURES
In the first setup, we evaluate all three Auto-Transfer configurations, full, fixed, and route, on various visual classification tasks, where transfer is from Resenet-34 model to a Resnet-18 model. Our findings are compared with an independently trained Resnet-18 model (Scratch), another Resnet-18 model tuned for ImageNet and finetuned to respective tasks (Finetune), and the following exist- ing baselines: Learning without forgetting (LwF) (Li & Hoiem, 2017), Attention Transfer (AT) (Zagoruyko & Komodakis, 2016), Feature Matching (FM) (Romero et al., 2014). Learning What and Where to Transfer (L2T-ww) (Jang et al., 2019) and Show, Attend and Distill (SAaD) (Ji et al., 2021). Results are shown in Table 6. Each experiment is repeated times.
First, note that the Auto- Tuto-fransfer Fixed configuration already improves performance on (almost) all tasks as compared to existing benchmarks. The fixed approach lets the target model decide how much source information is relevant when aggregating the representations. This result supports approach to feature combination and demonstrates that it is more effective than feature matching. This even applies to the benchmark methods that go beyond and learn where to transfer to. Next, note that the Trats-Trnsser Route configuration further improves the performance over the one-to- one configuration across all tasks. For example, on the Stanford40 dataset, Auto- Auto-Transfer Route improves accuracy over the second best baseline by more than 15% Instead of manually choosing source and target layer pairs, we automatically learn the best pairs through our AMAB setup (Table 5 shows example set of layers chosen by AMAB). This result suggests that learning the best pairs through our AMAB setup pick source-target pairs a useful strategy over manual selection as done in the one-to-one configuration. To further justify the use of AMAB in our training, we conducted an ablation experiment (section A.6) where we retrain Auto- Transfer (fixed) with bandit chosen layer pairs, and found that the results were sub-optimal.
Next, note that Auto-Transfer Full, which allows aggregation operations, does well but does not outperform Auto-Transfer Route. Indeed, the Auto-Transfer Full results showed that selected operations were all leaning to weighted addition, but other operations were still used as well. We conjecture that weighted addition is best for aggregation, but the additional operations allowed in Tuto-Trrnsser Full introduce noise and make it harder to learn the best transfer procedure. Ad- ditionally, conducted experiments by fixing aggregation to each of 5 operations and running Auto- Transfer Route and found that weighted addition gave best performance Table 8.
In order to demonstrate that transfer method does not rely the source and target networks being similar architectures, we proceed to transfer knowledge from a Resnet-32 model to a VGG-9 model. Indeed, Table 6 in the appendix demonstrates that Auto-Transfer significantly improves over other baselines for CIFAR 100 and STL-10 datasets. Finally, we conducted experiments on matched contigurations, where both auto-Transfer (Route) and FineTune used same sized source and target models and found that Auto Taao-Transser outperforms Fine (Figure 7 and Table 3).
4.3 EXPERIMENTS ON LIMITED AMOUNTS OF TRAINING SAMPLES
Transfer learning emerged as effective method due to performance improvements on tasks with limited labelled training data. To evaluate our Auto-Traan Transfer method in such data constrained sce- nario, we train Auto-Transfer Route method on all datasets by limiting the number of training samples. We vary the samples per class from 10% to 100% at 10% intervals. At 100%, Stanford40 has ~ 100 images per class. We compare the performance of our model against Scratch and 1.2T-ww
7

---

Published as a conference paper at ICLR 2022
Table 1: Transfer between Resnet models: Classification accuracy (%) of transfer learning from ImageNet
(224 x 224) to Caltech-UCSD Bird 200 (CUB200), Stanford Dogs datasets, MIT Indoor Scene Recognition (MIT67) and Stanford 40 Actions (Stanford40). ResNet34 and ResNet18 are used as source and target networks respectively. Best results are bolded and cach experiment is repeated 3 times. *DNR: did not report
Source task
ImageNet
Target task
CUB200
Stanford Dogs
MIT67
Stanford40
Scratch
39.1 to.52
57.87=t0.64
48.30
37.42
Finetune
41.38
54.76-13.55
18.50
37.15
LwF
45.52-L0.66
66.33-1-.45
13.73-
39.73+
AT
57.74
69.70
59.18
59.29
LwF+AT
58.90-
72.67=00.26
61.42
6.,20
FM
48.93-t0.40
67. 2..88
54.88=11.24
44.50
L2T-ww
65.05-+1.19
78.08
64.85
63.08
SAaD
68.29
76.06
66,47-1DNR
67.92
Auto- Auto-Trane Transfer
full
67.86=t0.70
84.07=00.2
74.79:t0.00
77.40=t0.74
fixed
64.86-L0.06
86. 10..0888
69.44-L0.41
77.27
route
74.76
86.16 0.224
75.86
80.10 F..5
for Stanford40 and report results in Figure 2 (top). Auto-Transfer Route significantly improves the performance over existing baselines. For example, at 60% training set (~60) images per class), our method achieves 77.90% whereas Scratch and L.2T-ww achieve 29% and 46%, respectively. To put Route requires only 10% images per class to achieve better accu-
this in perspective, racy than achieved by L2T-ww with 100% of the images. We see similar performance with other three datasets: CUB200, MIT67, Stanford Dogs (Figure 9).
4.4 IMPROVEMENTS IN TRAINING & INFERENCE TIMES
80
In order to assess training metrics and stability of learn- ing, we visualize the test accuracy over training steps in Figure (bottom) for the Stanford40 dataset. The results show that method learns significantly quicker relative to the second closest baseline. For example, at epoch 25, method achieves 74.55% accuracy whereas 1.2T-ww and Scratch achieve 25.55% and 21. 21.69% respectively. In terms of training time, Auto-Transfer Route took ~300 minutes to train 200 epochs on the Stanford40 dataset, whereas L2T-ww and Scratch models took 610 and 170
10
Auto-haralee (rcue))
80
60
minutes, respectively. Taken together, our method sig- nificantly improves performance over the second base- line with less than half the runtime. We report additional experiments with training curves plotted against training time in appendix (Figure 7) and inference times plotted against test accuracy (Figure 8). In Table 4 we show that for inference time matched models, Auto-Transfer (Route) outperforms Fine by significant margin.
Auto Transforr (route)
23
30
75
200
325
200
375
200
Figure 2: Above we see test accuracies as a function of (target) training sample size (top) and number of epochs (bottom) the Stanford40 datasct for the Seratch model, L2T-ww (our closest competitor) and our method Auto- Transfer. Qualitatively similar behavior is also seen the other datasets. Experiments repeated 3 times.
4.5 VISUAL EXPLANATIONS
In order to qualitatively analyze what bandit Auto- Transfer Route is learning, Grad-CAM (Selvaraju et al., 2017) based visual explanations are presented in Figure 3 (additional explanations are in Figures 11, 12, and 13 in the appendix). Sindd-AMM highlights pixels that played an important role in correctly labelling the input image. For each target task, we present (random) example image that is correctly labelled by bandit Tuto-fra but incorrectly classi-
8

---

Published as a conference paper at ICLR 2022
Input (MIT67)
Layer
Layer
Layer 3
Layer
scratch
gameroom 0:67
bedroom R=00.00
auto
P. 0.57
Input (CUB200)
scratch bluejay 0.85
bunting =.0
auto
bunting
P
Figure 3: Layer-wise Grad-CAN images highlighting important pixels that correspond to predicted output class. We show examples from MIT67 and CUB200 (ImageNet based transfer) where the independently trained scratch model predicted the input image incorrectly, but bandit based auto-transfer method predicted the right class for image. Correctly predicted class is indicated in green text incorrectly classified class indicated in red text. Class probability for these predictions is also provided.
fied by Scratch, along with layer-wise Grad-CAM images that illustrate what each layer of the target model focuses on. For each image, we report the incorrect label, correct label and class probability for correct (p.) and incorrect (p:) labels.
Overall, we observe that our method pays attention to relevant visual features in making correct de- cisions. For example, in the first image from MIT67 dataset, the Scratch model incorrectly labelled it as gameroom while the correct class is bedroom (p: 0.67, Pe 0.007). The Grad-CAM explanations show that layers 1-3 of the Scratch model pay attention to the green floor which is atypical to bedroom and common in gamerooms (e.g. pool tables are typically green). The last layer focuses on the surface below the window that looks like a monitor/tv that typically found in gamerooms. On the other hand, model correctly identifies the class bedroom (pe 0.57) by paying attention to the bed and surrounding area at each layer.
To visualize example from harder task, consider the indigo bunting image from the CUBS dataset. The Scratch model classifies the image as a bluejay (p; = 0.85, Pa 0.09), but our model correctly predicts it bunting (p.- 0.99). Indigo buntings and blue jays strikingly similar, but blue jays have white faces and buntings have blue faces. We clearly see this attribute picked up by the bandit Auto-Transfer model in layers and 3. We hypothesize that the source model, trained millions of images, provides useful fine-graine -ra-ggained information useful for classifying similar classes.
5 CONCLUSION
In this paper, we have put forth novel perspective where we leverage and adapt an adversarial multi-armed bandit approach to transfer knowledge across heterogeneous tasks and architectures. Rather than constraining target representations to be close to the source, we dynamically route source representations to appropriate target representations also combining them in novel and meaningful ways. Our best combination strategy of weighted addition leads to significant improvement over state-of-the-ane approaches on four benchmark datasets. We also observe that we produce accurate target models faster in terms of (training) sample size and number of epochs. Further visualization based qualitative analysis reveals that our method produces robust target models that focus on salient features of the input more so than its competitors, justifying superior performance.

---

Published as a conference paper at ICLR 2022
ACKNOWLEDGMENT
We would like to thank Clemens Rosenbaum, Matthew Riemer, and Tim Klinger for their com- ments earlier version of this work. This work was supported by the Rensselaer-IBM AI Research Collaboration (http:/ //arrc.rpp..... edu), part of the IBM Al Horizons Network wwt.m.iii/iiBH. htt.bbmmiiii/AHtiioooons...
REFERENCES
Peter Auer, Nicolò Cesa-Bianchi, Yoav Freund, and Robert E. Schapire. The nonstochastic multi- armed bandit problem. SIAM J. Comput., 32:48-77, 2002.
Mohsen Bayati, Nima Hamidi, Ramesh Johari, and Khashayar Khosravi. Unreasonable effectiveness of greedy algorithms in multi-armed bandit with many arms. Advances in Neural Information Processing Systems, 33, 2020.
Yu-An Chung, Hung- Yi Lee, and James Glass. Supervised and unsupervised transfer learning for question answering. arXiv preprint (7Xiv:/711.05355 2017.
Adam Coates, Andrew Ng. and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelli- gence and statistics, pp. 223. JMLR Workshop and Conference Proceedings, 2011.
Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hi- erarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248-248822 255. Ieee, 2009.
Amit Dhurandhar, Karthikeyan Shanmugam, Ronny Luss, and Peder Olsen. Improving simple mod- cls with confidence profiles. Advances in neural information processing systems. 2018.
Amit Dhurandhar, Karthikeyan Shanmugam, and Ronny Luss. Enhancing simple models by ploiting what they already know. International Conference on Machine Learning, 2020.
Eyal Even Shie Mannor, Yishay Mansour, and Sridhar Mahadevan. Action elimination and stopping conditions for the multi-armed bandit and reinforcement learning problems. Journal of machine learning research, 7(6), 2006.
Ross Girshick. Fast r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 1440-1448, 2015.
Yunhui Guo, Honghui Shi, Abhishek Kumar, Kristen Grauman, Tajana Rosing, and Rogerio Feris. Spottune: transfer learning through adaptive fine-tuning. Proceedings of the IEEE/CVE Con- ference Computer Vision and Pattern Recognition, pp. 4805-4814, 2019.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog- nition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp- 770-778, 2016.
Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross Girshick. Mask r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 2961-2969, 2017.
Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge neural network. arXiv preprint arXiv:1503.02533 2015.
Sergey loffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, pp. 448-456. PMLR, 2015.
Yunhun Jang, Hankook Lee, Sung Ju Hwang, and Jinwoo Shin. Learning what and where to transfer. In International Conference on Machine Learning, pp. 3030-3039. PMLR, 2019.
Mingi Ji, Byeongho Heo, and Sungrae Park. Show, attend and distill: Knowledge distillation via attention-base feature matching. In Proceedings of the AAAI Conference on Artificial Intelli- gence, volume 35, pp. 7945-7952, 2021.
10

---

Published as a conference paper at ICLR 2022
Aditya Khosla, Nityananda Jayadevaprakash, Bangpeng Yao, and Fei-Fei Li. Novel dataset for fine- grained image categorization: Stanford dogs. In Proc. CVPR Workshop on Fine-Gree Greairr Visual Categorization (FGVC), volume 2. Citeseer, 2011.
Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
Xingjian Li, Haoyi Xiong, Hanchao Wang, Yuxuan Rao, Liping Liu, and Jun Huan. Delta: Deep learning transfer using feature map with attention for convolutional networks. In International Conference on Learning Representations, 2018.
Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE transactions pattern analysis and machine intelligence, 40(12))2935-2994, 2017.
Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3431-3440, 2015.
Dhruv Mahajan, Ross Girshick, Vignesh Ramanathan, Kaiming He, Manohar Paluri, Yixuan Li, Ashwin Bharambe, and Laurens Van Der Maaten. Exploring the limits of weakly supervised pretraining. In Proceedings of the European conference on computer vision (ECCV), pp. 181- 196, 2018.
Sewon Min, Minjoon Seo, and Hannaneh Hajishirzi. Question answering through transfer learning from large fine- grainerinnd supervision data. arXiv preprint urXiv:1702.02117 2017
Behnam Neyshabur, Hanie Sedghi, and Chiyuan Zhang. What is being transferred in transfer learn- ing? arXiv preprint arXiv:2008. 1687, 2020.
Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345-135) 2009.
Ariadna Quattoni and Antonio Torralba. Recognizing indoor scenes. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 413 IEEE, 2009.
Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. Advances in neural information processing systems, 28: 91-99, 2015.
Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. arXiv preprint arXiv:1412.6550 2014.
Clemens Rosenbaum, Tim Klinger, and Matthew Riemer. Routing networks: Adaptive selection of non-linear functions for multi-task learning. In International Conference on Learning Represen- tations, 2018
Jeongun Ryu, Jaewoong Shin, Hae Beom Lee, and Sung Ju Hwang. Metaperturb: Transferable regularizer for heterogeneous tasks and architectures. Advances neural information processing systems, 2020.
Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruy Batra. Grad-cam: Visual explanations from deep networks via gradient-based local- ization. In Proceedings of the IEEE international conference on computer vision, pp. 618-626, 2017.
Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. Cnn features off- the-shelf: an astounding baseline for recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pp. 806-813 813, 2014.
Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556 2014.
Suraj Srinivas and François Fleuret. Knowledge transfer with jacobian matching. In International Conference Machine Learning, pp. 4731. PMLR, 2018
11

---

Published as a conference paper at ICLR 2022
Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. Revisiting unreasonable ef- fectiveness of data in deep learning era. Proceedings of the IEEE international conference on computer vision, pp. 843 852, 2017.
Yun-Yun Tsai, Pin-Yu Chen, and Tsung-Yi Yi Ho. Transfer learning without knowing: Reprogramming black-box machine learning models with scarce data and limited resources. In International Conference on Machine Learning, pp. 9614-9624, PMLR, 2020.
Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie. The caltech-uesd birds-200-2011 dataset. 2011.
Yijun Wang, Yingce Xia, Li Zhao, Jiang Bian, Tao Qin, Guiquan Liu, and Tie Yan Liu. Dual transfer learning for neural machine translation with marginal distribution regularization. In Proceedings of the AAAI Conference Artificial Intelligence, volume 32, 2018.
LI Xuhong, Yves Grandvalet, and Franck Davoine. Explicit inductive bias for transfer learning with convolutional networks. In International Conference on Machine Learning, pp. 2825-2834. PMLR, 2018.
Bangpeng Yao, Xiaoye Jiang, Aditya Khosla, Andy Lai Lin, Leonidas Guibas, and Li Fei-Fei. Hu- man action recognition by learning bases of action attributes and parts. In 2011 International conference on computer vision, pp. 1331-1338. IEEE, 2011.
Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the perfor- mance of convolutional neural networks via attention transfer. arXiv preprint arXiv:16/2.03928, 2016.
Barret Zoph, Deniz Yuret, Jonathan May, and Kevin Knight. Transfer learning for low-resource neural machine translation. arXiv preprint arXiv: 1604. 02201, 2016.
12

---

Published as a conference paper at ICLR 2022
A APPENDIX
A.1 TOY EXAMPLE
In this section, we simulate our experiment on a toy example. We compare our Auto-Transfer with the other baselines: L2T-ww and Scratch. In this simulation, we consider Auto-Transio Transfer with fixed (one-to-one) setup for simplicity our experiment analysis.
We consider predicting sine wave function (y = sin(x)) as source task and sinc function (y =in(2)) as our target task. Clearly, the features from the pretrained source model will help the at
target task in predicting the sinc function. Both the input data point x and the output value are one-dimensional vectors (din dout 1). We use a shallow linear network consists of 4 linear blocks: fi Lin
(2))))) fa = Lin(h, (22)))))))))))))))))))) oul Lin (Ja) for a datapoint x. For source network, we set the hidden size to (i.e., h1 h2 hg 64) and 16 for the target network. We sampled 30, 000 data points to generate training set (x.y) and 10, 000 test-set data points for the source network and (i.e., x is sampled from Gaussian distribution and y sin(x:)) Similarly, generated 1000 training examples and 800 test examples for the target network. Both the source and the target networks are trained for E = 50 epochs.
(d,) .A.) (x), J2
Sine (with noise)
Sinc (with naise) Auto-Transfer L2T-Ww
-Source diction
Scratch
0.-
Source Prediction
-02
-02
-0.4
-0.6 -3.0
-25
6.2
25
-10
Figure 4: (Left) shows the test set data from the source task and the source models' prediction. (Right) shows the test-set predictions for target task data from Scratch, Source prediction, L2T-ww and Auto-Transfer with the shallow linear network configuration [d.,. h, 16, 16, ha 16, doue =
Figure 4 (left) shows the source model prediction for the test data. Given the shallow linear network with 64 hidden dimensions and 30, 000 training example, the source model perfectly predicts the sin(x) function. Figure (right) shows the predictions from the scratch target model, source model, L2T-ww and Auto-Transfer for the target test data. We report the Auto aato-Transfer with fixed choice of (1.,),,, wtAdd] for this experiment. We can that the Auto-Transfe accurately predicts the target task even when there is a limited amount of labeled examples.
Our results show the test set loss for the target data relatively less compared the other baselines (0.0030 MSE loss for Auto- Transfer vs 0.0033 and 125 MSE loss for the scratch and L2T-ww). Figures 5 and 6 show The results different network configurations and how the feature represen- tations for Scratch, L.2T-ww and Auto-Transfer changes over 50 training epochs.
A.2 REAL DATASETS
We evaluate the performance of Auto-Transfer on six benchmarks with different tasks: Stanford Actions 40 dataset for action recognition, CUBS Birds 200 dataset for object recognition, Stanford Dogs 120 for fine-grained object recognition, MIT Indoors 67 for scene classification, CIFAR 100 and STL-10 image recognition datasets.
Stanford Actions 40. Stanford Actions 40 dataset contains images of humans performing 40 ac- tions. There are about 180-300 images per class. We do not use bounding box and other annotation information for training. There are total 9,532 images, making it the smallest dataset in our benchmark experiments.
13

---

Published as a conference paper at ICLR 2022
02
62-
-02
-0.
Figure 5: Test-set predictions for Scratch, Source prediction, L2T-ww and Auto-Transfer for the target task data with the shallow lincar network configurations left: [din 1, h1 = 4, h2 = 4, ha = 4, doue = 11, right: [din = 1, = 12 = 8, hi = 8, dout = 1]
-65
-10
-Scratch
-15-
-L2T-ww
Auto-Transse
-04
Figure 6: Test-set predictions Scratch, Source prediction, 1.2T-wW and Auto-Transfer for target task data with different choices from the routing function left: (2,,0)(-1,1)(x1122,,, wAdd] right: show the feature representations of single data point (plotted over the 50 training epochs) extracted from the final layer of the target network
Caltech-UCSD Birds-200-2011. CUB-200-2011 is bird classification datset with 200 bird species, Each species is associated with a wikipedia article and organized by scientific classifi- cation. Each image is annotated with bounding box, part location, and attribute labels. We use only classification labels during training. There are a total of 11,788 images.
Stanford Dogs 120. The Stanford Dogs dataset contains images of 120 breeds dogs from around the world. There are exactly 100 examples category in the training set. It is used for the task of fine-grained image categorization. We do use the bounding box annotations. There are total of 20,580 images.
MIT Indoors MIT Indoors 67 scene classification task containing 67 indoor scene cate- gories, each of which consists of at most 80 images for training and 20 for testing. Indoor scene recognition is challenging because spatial properties, background information and object characters expected to be extracted. There 15,620 images in total.
CIFAR 100. CIFAR 100 is a image recognition task containing 100 different classes with 600 images in each class. There are 500 training images and 100 testing images per class. It is subset of tiny images datastet.
STL 10. STL 10 is image recognition task containing 10 classes. It is inspired by the CIFAR-10 dataset but with some modifications. In particular, each class has fewer labeled training examples than in CIFAR-10.
14

---

Published as a conference paper at ICLR 2022
A.3 EXPERIMENT DETAILS
For our experimental analysis in the main paper, we set the number of epochs for training to E 200. The learning rate for SGD is set to 0.1 with momentum 0.9 and weight decay 0.001. The learning rate for the ADAM is set to 0.001 with and weight decay of 0.001. We use Cosine Annealing learning rate scheduler for both optimizers. The batch size for training is set to 64. Our target networks were randomly initialized before training.
The target models were trained in parallel on machines with the specifications shown in Table
2.
Resource
Setting
CPU
Intel(R) Xeon(R) CPU E5-2690 v4 @ 2.60GHz
Memory
128GB
GPUs
NVIDIA Tesla V100 16 GB
Disk
600GB
OS
Ubuntu 18.04-64 Minimal for VSI.
Table 2: Resources used by Auto-Transia
A.4 TRAINING AND TESTING PERFORMANCE
CUB200
Stanford Dogs
70
80
40
30
20
250
50
MIT67
Stanford40
80
70
60
Test accuracy (50)
60
50
40
FT(18-18)
10
AT(18-18)
10
AT(34-18)
50
100
150
200
250
20
40
120
140
Training Time (minutes)
test accuracies function of training time (minutes) plotted for following archi- lectures (i) Finetuning (ResNet18 ResNet18), (ii) AutoTransfer (ResNet18 ResNet18). (iii) AutoTransfer (ResNet34- ResNet18), denoted FT(18-18), AT(18-18), AT(34-18), respectively. significantly outper- form finetuning in all datasets.
Figure 7: Above
A.5 ADDITIONAL EXPERIMENTS ON LIMITED AMOUNTS OF DATA
To evaluate Auto-Transfer method in data constrained scenario further, train Auto- Transfer (route) method on the CUB200, Stanford Dogs and MIT67 datasets by limiting the number of training samples (Figure 9). We vary the samples per class from 10% to 100% 10% intervals.
15

---

Published as a conference paper at ICLR 2022
Table 3: Classification accuracy (%) transfer learning matched architectures ResNet18 ResNet18 for Transfre and Finetuning. Best results are bolded.
CUB200
Stanford Dogs
MIT67
Stanford40
Finetune (R18- R18) AutoTransfer (R18 R18)
42.96:E145
53.02.13.57
47.9313366
34.40:1:.99
66.97-11.38
19.06-11.05
69.54
75.07-1:..55
Table 4: Average classification accuracy (%) and average inference times of transfer learning for time matched architectures using ResNet18 ResNet18 for Auto-Transfer and ResNet34 ResNet34 for Finetuning.
CUB200
Stanford Dogs
MIT67
Stanford40
(sec)
t
%
Finetuning (R34 R34)
12.88
37.13
12.66
52.26
12.22
44.37
14.0
31.12
Auto-Transfer (R18- R18)
14.46
64.37
13.83
77.07
14.26
67.89
15.28
69.02
Auto-Transfer (R34- R13
18.55
71.84
18.27
85.09
18.62
69.76
19.20
79.74
Table 5: Final source layer selected at 200th epoch for each target layer for 3 repetitions for Table experiments.
Selected source layer (run run 2, run
Target Layer
Layer
Layer 2
Layer 3
Layer
CUB200
2,
3.2.2
2, 1,
2. 4,
Stanford Dogs
1,
3.3.5
2,3,2
5,
MIT67
2,
3,5
2,3,
3.3.4
Stanford40
1,2,4
4,3.3
2,3.2
3.4.
Table 6: Transfer between Resnet model and VGG model: from TinylmageNet CIFARI00 and VGG9, ResNet32 and VGG9 used source and target networks respectively, Best results bolded and each experiment repeated times.
Classification accuracy (%) of transfer lcarning
Source task
TinyImageNet
Target task
CIFAR100
STL-10
Scratch
67.69-to.22
65.18
Finetune
6..80
65. 65.98-11.25
LwF
69.23
68. 18.64
AT
67.54-L0.0
14.19::0.2
LwF+AT
68. 68.75
75.06
FM
69.97
76.38
L2T-ww
70.96
76.38
Auto-Transfer
full
72.48-L0.42
78, 78,46111.10
fixed
70.48
79.92+1149
route
70.89
82.09
16

---

Published as a conference paper at ICLR 2022
CUB200
Stanford Dogs
MIT67
Stanford40
75
70
80
70
65
Test accuraty
50
55
FT(34-34)
40
AT(18-18)
50
30
AT(34-18)
Inference (seconds)
Figure 8: Test accuracies as a functiion of inference time plotted for following architectures (i) Finetuning (ResNet34 - ResNet34), (ii) AutoTraanser (ResNet18 ResNet18), (iii) AutoTTrnnsfer (ResNet34 ResNet18), denoted FT(34-34) AT(18-188 and AT(34-18), respectively. Each circle represents batch of 128 sample images. We significantly outperform finetuning in all datasets.
CUB200
Stanford Dogs
MIT67
70
Test acoursy
20
20
10
harrfer
Training sample (61
Figure 9: Above we test accuracies function of (target) training sample size for CUB200, Stanford Dogs and MIT67 datasets. Each experiment is repeated 3 times.
A.6 ABLATION STUDIES
TRAINING THE NETWORK USING BANDIT SELECTED PAIRS
To evaluate the importance of training the target network with adversarial multi-armed bandit, we retrained our target network with a fixed source-layer configuration selected at 200th epoch of pre- vious best bandit based experiments. For Eg. in our best bandit based experiment for CUB200, the tauree,target pairs were ((2.1), (3,2), (2,3), (2,4)). As seen in Table 7, we find that this experiment decreased performance in comparison to bandit based one in all target tasks. This confirms the need for bandit based decision maker, that learns combination weights and pairs over training steps.
Table 7: Classification accuracy (%) of transfer lcarning ResNet34 to ResNet 8 transfer where the source-target layer pairs are fixed to Auto Transfrrreer (route) selected ones at 200th epoch from previous runs.
Task
CUB200
Stanford Dogs
MIT67
Stanford40
Outo-Transfer (fixed, retrain) Auto-Transfer (route)
73.09
85.05
69.10 76.87
78.90
75.15
86.40
80.68
TRAINING THE NETWORK USING DIFFERENT AGGREGATION OPERATORS
To evaluate how different aggregation operators influence Auto-Transfer, we train Auto-Transfer Route by fixing aggregation to different operations. Identity (iden), Simple Addition (sAdd), Weighted Addition (wtAdd), Linear Combination (LinComb) and Factored Reduction (FactRed). Results for Stanford40 dataset is found in Table 8. We find that weighted addition performs the best.
17

---

Published as a conference paper at ICLR 2022
Table 8: Classification accuracy (%) of transfer learning ResNet34 to ResNet18 transfer where the aggregation operator is fixed to Identity (iden), Simple Addition (sAdd), Weighted Addition (wtAdd), Linear Combination
(LinComb) and Factored Reduction (FactRed).
Iden
SAdd
WtAdd
LinComb
FactRed
Auto-Transfer (route)
37.56
77.78
80.10
76.6
76.66
A.7 VISUALIZING INTERMEDIATE REPRESENTATIONS
Input image
Layer
Layer
Layer
Layer
Figure 10: Example of learned intermediate representations for bird image from CUB200 dataset. We plot the first features each layer there are 64, 128, 256 and 512 features for layers to 4). is hard to draw meaningful patterns by looking at intermediate representations, and hence we chose to investigate layer-wise Grad-CAM images.
A.8 ADDITIONAL. EXPLANATIONS USING GRAD-CAM
We here offer more examples of visual explanations of what is being transferred using Auto-Transfer Route. The first example in Figure 11 an image of cooking from the Stanford40 dataset. The Scratch model incorrectly classifies the image cutting (p: 0.88, P. = 0.01) by paying attention to only the cooking surface that looks like a table and person sitting down (typical for someone cutting vegetables). On the other hand, our model correctly labels the image (p.- 0.99) by paying attention to the wok and cooking utensils such as water pot, etc. We hypothesize that this surround- ing information is provided by the source model which is useful in making the correct decision.
The second example in Figure 11 is from the Stanford Dogs dataset (Figure 11). The scratch model fails to pay attention to relevant class information (dog) and labels chihuahua german sheperd (p; = 0.23, Pe = 0.0002) by focusing on the flower, while our method picks the correct label (Pc 0.99). Bandid Auto-Transfer gets knowledge about the flower early and then disregards this knowledge before attending to relevant class information. Further examples of visual explanations comparing L2T-ww (Figure 12) and counter-examples where our method identifies the wrong label (Figure 13) follow below. For these counter-example we find that the task is typically hard. For eg. playing violin playing guitar. And, the class probability of incorrect label is closer that of correct label, suggesting that our method was not confident in predicting wrong class.
18

---

Published as a conference paper at ICLR 2022
Layer 1
Layer 2
Layer
Layer 4
Input (Stanford40)
scratch cutting
Pi 0.88
cooking P. 0.01
auto cooking Pe 0.99
Input (Stanford Dogs)
scratch
sheperd = 0.23
chihuahua P. 0.0002
auto chihuahua
Pe = 0.99
Figure 11: Layer-wise Grad-CAM images highlighting important pixels that correspond to predicted output class. We show examples from Stanford40 and Stanford Dogs (ImageNet based transfer) where the indepen- dently trained scratch model predicted the input image incorrectly, but bandit based auto-transfer method predicted the right class for that image. Correctly predicted class is indicated green text and incorrectly classified class is indicated in red text. Class probability for these predictions is also provided.
19

---

Published as a conference paper at ICLR 2022
Input (Stanford40)
Layer
Layer
Layer 3
Layer
12t-WW
rowing boat
p 0.94 fishing
= 0.01
auto
fishing
0.97
Input (Stanford40)
12t-ww
fishing
= 0.77
gardening
0.0004
auto
gardening
0.50.
Input (MIT67)
12t-wW
gameroom
0.99
bedroom
p.= 0.0002
auto
bedroom 0.99
Input (MIT67)
12t-WW
fastfood
p
0.09
auto
casino
0.67
Figure 12: Layer-wise Grad-CAM images highlighting important pixels that correspond predicted output class. show examples where the L2T-ww model predicted the input image incorrectly, but our bandit based auto-transfer method predicted the right class for that image. Correctly predicted class is indicated in green text and incorrectly classified class is indicated in red text. Class probability for these predictions is also provided.
20

---

Published as a conference paper at ICLR 2022
Layer 1
Layer 2
Layer 3
Layer 4
Input (MIT67) DIECA ZOBE
auto classroom
P, 0.43 kindergarten
Pe 0.33
12t-ww kindergarten P. 0.91
Input (Stanford40)
auto play guitar p violin
P.= 0.30
12t-ww play violin
P. = 0.84
Figure 13: Layer-wiss Grad-CAM images highlighting important pixels that correspond to predicted output class. We show examples where the L2T-ww model predicted input image correctly, our bandit based auto-transfer method predicted the wrong class for that image. Correctly predicted class indicated in green text and incorrectly classified class indicated in red text. Class probability for these predictions is also provided.
21


Reviews:
[{"review_id": "qw0R4lp5ZbF", "reviewer": "Reviewer_7soo", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "Strengths:\n* I like the principled approach to letting the model figure out what information to transfer. The additional inductive bias of constraining the information flow could be useful to directly inspect what information is being transferred between the networks. \n\nWeaknesses:\n* Evaluation setup: is there a standard benchmark for this task? And more recent baselines? If your interest in this setup is driven by addressing scenarios with limited amounts of labels, more careful evaluation of this scenario would be meaningful to add.\n* Ablation studies: it would be interesting to investigate deeper the effect of choosing adversarial bandits in this context. The Appendix reports an ablation study with a fixed routing choice, but other baselines could be interesting too. What's the effect of the frequency of updates of the bandit? How do different parts of the proposed method impact the overall effectiveness? How does the choice of number of representations influence the performance? Are these learned intermediate representations meaningful?\n* The authors mention the ability to decide whether to overwrite the target's network own information as an advantage of their method. Are there ways to test this hypothesis? It seems like giving the option to let the network choose the aggregation operation resulted in always the same choice, \n\nMinor:\n* Some experimental details are missing, for example how many random initializations where tried to compute the variance over the reported accuracy?\n* Time improvements: how do the results depend on the complexity of the routing problem?\n", "summary_of_the_paper": "This work addresses the challenge of automatic knowledge transfer between different networks. The authors propose to use an adversarial  multi-armed bandit to decide where, what and how to combine outputs from different layers of the two networks, improving on the recent line of work that achieves transfer by enforcing closeness between the representations obtained by the two networks.\n\nFor each layer, the proposed method introduces some additional parameters in the form of intermediate representations and parametrized ways to combine such intermediate representations with the source network's output.  The multi-armed bandit is trained to choose which intermediate representation and which aggregating function to use. The reward is determined based on a hold out set. The authors compare the proposed approach with some previous work, showing improvements, and perform a qualitative analysis of the results.", "summary_of_the_review": "While the authors address an important problem with an interesting technique, a more principled evaluation would be necessary for this work to be complete. The task should be better contextualized within the existing literature, and the proposed method evaluated more throughly. ", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "2: Several of the paper’s claims are incorrect or not well-supported.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "2: The contributions are only marginally significant or novel."}, "extra_text": {}}, {"review_id": "qEKbc4FiWQI", "reviewer": "Reviewer_3TiT", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "Transfer learning is becoming an important tool for applied machine learning. On one hand, it can help to save lots of energy and compute by training once and benefitting many times from it. On the other, it can unlock the use of small datasets that, in isolation, are hard to crack. Accordingly, any development in this front can have significant consequences in the practical use and adoption of modern deep learning (or ML, more broadly). So far, the golden standard is to finetune the model on the new dataset (maybe after distilling to the target architecture if needed, and possibly by applying some additional regularization to avoid overfitting or diverging too much from the original model).\n\nThis paper proposes an alternative. There are many ways to use the source predictions and representations in a potentially useful downstream manner. Rather than choosing one, and just committing to it in all cases (e.g., full finetuning), they propose an adaptive mechanism that operates in two dimensions. First, it essentially considers a set of architectures (one for each potential source-target plugging). Second, for a given wiring, it trains part of it (all except the original source network which remains frozen) on the downstream data. The former is a discrete optimization problem, the latter is a continuous one. A bandit algorithm (Algorithm 1) and gradient descent (Algorithm 2) are used respectively, in an alternating fashion. \n\nIn my opinion, the idea is quite natural. There are some subtleties, though. Algorithm 2 changes the \"environment\" by training, so it's a non-stationary problem. Also, rather than considering the joint (or say, Cartesian product) action space, the algorithm solves one bandit problem per target layer as an independent instance. The reward designed by the algorithm (given in Algorithm 3, line 2) assumes no \"decision\" is applied in the other bandits problems, and tries to find the best action for the layer while assuming there won't be any wiring in the remaining target layers (if I understand correctly).\n\nI find the experimental section to be a bit limited.\n\nFirst, the simplest baseline I can think of (source and target identical architectures, and finetune source into target) is not there: ResNet X to ResNet X. There's a comparison (\"Scratch (finetune)\") where a smaller source network (RN18) is used to help the target (RN18), but still compared with Auto-Transfer on a RN36 source network, so not exactly apples to apples. It would be extremely informative to see this comparison as I think it is the cleanest one. Moreover, the direct finetuning should be much faster; can we also see a time-matched comparison (i.e. train for the same amount of time the RN-X to RN-X finetune transfer and the Auto-Transfer approach)? I'll raise my score if this is added (and given the numbers in Table 1, I'd be confident this should still work well for Auto-Transfer).\n\nThe numbers in Table 1 are really impressive: Auto-Transfer seems to offer massive gains. There's only 4 datasets though, considering something like VTAB [1] could improve the work (it contains a large number of diverse downstream vision tasks). Also, it'd be interesting to see a more detailed ablation to understand which aspects of the algorithm really explain the gains. Is the bandit algorithm fundamentally important? Can we use a simple UCB? Or even an epsilon greedy approach based on the average reward? Or is it mostly about the action set --some of this is shown in the full/fixed/route comparison? For example, rather than applying the (somewhat complex) Auto-Transfer algorithm every time we want to transfer, a more desirable outcome would be to discover specific combinations (i.e. actions in the action set) --that is, transfer design principles-- that work well across many different setups. Maybe we can look at the finally selected ones for the datasets in Table 1, find a simple common pattern (i.e. one choice of the action set), and train with this fixed choice, and see how it does? In those cases, maybe rather than the algorithm, the contribution could also include some high level wiring tips (this may seem at first less appealing as it's tailored towards one specific architecture: resnet, transformer, etc) but it could have a much bigger impact.\n\nA potential explanation to beating simple finetuning may have to do with the intrinsic memory that this algorithm provides. In some sense, by paying in terms of inference cost and storage, we can't forget the original representations. The final models have very different size/dimension/power (if you keep the source model or not around). \n\nThis leads to another big question: inference. Regardless of the cost and complexity of finetuning, the proposed approach requires that during inference we'll need to apply both networks (source and target). Moreover, in general sequential processing is needed: you have to run source first, as its last layer representation could be wired to the first target layer one. Can you provide results where the inference time is matched (ignoring complexity)? In other words, compare a larger model directly finetuned to, with two smaller source and target networks trained via Auto-Transfer, so that total inference flops or runtime in both cases are identical. At the end of the day, these considerations probably matter a lot in real practical systems. Looking at Figure 2, I could be optimistic about these cost-matched comparisons, if one model is able to unlock much higher performance values, then it seems no matter how much time you devote to the suboptimal one, it may not be able to catch up.\n\n\n[1] = A Large-scale Study of Representation Learning with the Visual Task Adaptation Benchmark", "summary_of_the_paper": "The paper proposes an algorithm to transfer a \"source\" pre-trained deep model into a new one for a given target task. The idea is to wire in a certain way the intermediate representations of the source model into those of the \"target\" one. The algorithm considers a (small) discrete space of potential such ways to connect both models (location, source processing, and type of merging), and applies a bandit algorithm to sequentially spend training budget under one of the configurations. Experiments are provided that show big gains with respect to standard approaches (like finetuning the source model).", "summary_of_the_review": "The paper proposes a sequential decision making idea to do transfer learning using and keeping two networks: pre-trained source and from-scratch target. The results that are presented suggest Auto-Transfer offers large gains, but the scope of the experimental section is a bit limited.\n\n--------------\n\nAfter reading the detailed reply by the authors, I decided to raise my score: 5 --> 6.\n", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "4: All of the claims and statements are well-supported and correct.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work."}, "extra_text": {}}, {"review_id": "k7wJaxDvjLh", "reviewer": "Reviewer_u325", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "\n1. The method may be not novelty enough. It tries to introduce reinforcement learning into transfer learning to route transferable representations. The reinforcement learning part utilizes a traditional bandit-based method while routing choices are common choices that have been used in existing work widely.\n2. It is better to add more latest state-of-the-art comparison methods. This paper only compares with methods used in L2T-ww. However, L2T-ww is a paper proposed in 2019, which cannot represent the best results now. Some more work, such as SNOW[1], has been proposed for knowledge transfer. \n3. Since the paper is similar to L2T-ww, a method proposed in 2019, it is better to compare all results showed in L2T-ww. And more new benchmarks are needed.\n\nOverall, I recommend rejecting the current version of the paper.\n\n[1] Yoo C, Kang B, Cho M. SNOW: Subscribing to Knowledge via Channel Pooling for Transfer & Lifelong Learning of Convolutional Neural Networks[C]//International Conference on Learning Representations. 2020.", "summary_of_the_paper": "To transfer knowledge between heterogeneous source and target networks and tasks, this paper proposes a novel adversarial multi-armed bandit approach (AMAB) which automatically learns to route source representations to appropriate target representations. It combines feature representations received from the source network with the target network-generated feature representations via various aggregation operations. The work is interesting and makes sense to some extent.\n", "summary_of_the_review": "See main review.", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work."}, "extra_text": {}}, {"review_id": "Byfjfp1uLoZ", "reviewer": "Reviewer_8d9w", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "Pros: \n\n- The proposed approach does a good job at transferring representations between heterogeneous CNNs, showing good results in several image classification datasets and improving upon state-of-the-art solutions.\n\n- The algorithm is relatively easy to implement and results should be reproducible. Code is provided.\n \n##########################################################################\nCons: \n \n \n- There seems to be a disconnect between the general idea presented in the paper and the “flavor” of the approach that yields the best results. In practice, the idea of using multi-arm bandits to learn features mapping along with a set of transformation and combination operators seems to be reduced to learning the feature mapping fixing those operators. If this is the case, the narrative of the paper should reflect the finding (from the beginning of the manuscript). If this is not the case, empirical evidence should support it.\nThis observation affects the consistency of the paper and triggers multiple questions that need to be addressed during the rebuttal period.\n\n##########################################################################\nQuestions during rebuttal period: \nWhy did authors choose a normalized linear operator for the transformation of the source features (i.e., Tj = BN(Conv(·)) )? Were other operators analyzed and discarded? Is the idea just to adjust channel dimensions and address the covariant shift? \t\n\t\t\t\nFrom table 1, it seems that fixing the combination operator to be a weighted addition and the aggregator operator to be a bilinear interpolation yields the best results. The “full” configuration, in which the multi-arm bandits’ algorithm has to select these operators comes in second place. Shouldn’t this observation deeply affect the original hypothesis of this work as well as the global structure of the paper?  \n\nAs a follow-up to the previous question, could the authors provide additional details on the “fixed configuration”? From the text, it is clear that the feature maps are done manually, but is the combination operator set to a weighted addition, and is the aggregator operator set to a bilinear interpolation? After observing how the \n“route configuration” outperforms the “full configuration” I wonder if the “fixed configuration” could be further improved by fixing those operators to a weighted addition and a bilinear interpolation. Could authors please report a configuration with these details? \t\t \t ", "summary_of_the_paper": "The paper presents a new approach to perform transfer learning between heterogeneous architectures and tasks by introducing a new algorithm based on adversarial multi-armed bandit, which automatically learns a mapping between source and target representations, as well as the way to combine such representations. The approach is evaluated in multiple vision tasks, starting from models pre-trained on ImageNet, producing satisfactory results when compared to the state-of-the-art.", "summary_of_the_review": "I am currently indecisive, leaning towards rejection. The paper presents a nice narrative about the adversarial multi-armed bandit approach, highlighting the benefits of the routing of representations in combination with the dynamic selection of operators to combine and transform features. However, experiments seem to hint at a different reality, where fixing these operators is indeed more beneficial.  Based on this, I consider that authors need to present stronger evidence that supports the value of the approach, as it is currently presented in the paper, or they need to update the narrative of the paper to account for the empirical findings.\n \nPlease, consider my questions for rebuttal.\n\nPost-rebuttal review:\n\nAfter the evidence provided by the authors, I have decided to increase the valuation to a 6: marginally accepted. The new tables are able to defend the value of the main idea, but still, there are some doubts about the potential of \"full\" vs. \"route\" in different problems/datasets. This is the main reason for not assigning a higher score.\n", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "2: Several of the paper’s claims are incorrect or not well-supported.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work."}, "extra_text": {}}]

Author rebuttal:

Meta-review: This paper tackles the problem of how to utilize a network from the source domain to benefit target domain training in terms of sample/training efficiency. In contrast to prior methods (e.g. that perform fine-tuning or distillation), this paper poses it as a bandit problem that decides how to wire intermediate representations of the source model into the target model as well as what aggregation function to use. An alternating/mixed discrete-continuous optimization is proposed to perform this decision-making, and results are shown across a mix of source-target pairs and network architectures. 

  The reviewers overall found the method interesting and paper topic both interesting and extremely practically useful, presenting an opportunity to save significant energy, compute, and labeling requirements when training on target domains. The results also show very significant improvements, on the conditions tried. However, a number of concerns were raised including comparison to simple same-architecture fine-tuning (3TiT), comparison benchmarks e.g. VTAB and newer methods in the area (u325, 7soo, 3TiT), need for the adversarial bandit formulation (3TiT, 7soo, 8d9w), and the added storage/inference costs required (3TiT). 

  Based on these reviews, the authors provided a thorough rebuttal, additional baselines and experiments demonstrating the efficacy of the method (especially the full version) over both reasonable simple baselines (same architecture fine-tuning) as well as simpler versions (fixed aggregation), and time/inference-time matched performances. Importantly, the advantage of the full method comes out a lot more in the new experiments. Overall, through the rebuttal process the paper has been made much stronger. 

  Given that the paper provides a nice principled approach to the problem and now has strong compelling results, I recommend acceptance.
Decision: Accept (Poster)