Year: 2018

Abstract:
Few-Shot Learning (learning with limited labeled data) aims to overcome the limitations of traditional machine learning approaches which require thousands of labeled examples to train an effective model. Considered as a hallmark of human intelligence, the community has recently witnessed several contributions on this topic, in particular through meta-learning, where a model learns how to learn an effective model for few-shot learning. The main idea is to acquire prior knowledge from a set of training tasks, which is then used to perform (few-shot) test tasks. Most existing work assumes that both training and test tasks are drawn from the same distribution, and a large amount of labeled data is available in the training tasks. This is a very strong assumption which restricts the usage of meta-learning strategies in the real world where ample training tasks following the same distribution as test tasks may not be available. In this paper, we propose a novel meta-learning paradigm wherein a few-shot learning model is learnt, which simultaneously overcomes domain shift between the train and test tasks via adversarial domain adaptation. We demonstrate the efficacy the proposed method through extensive experiments.

heading: 1 INTRODUCTION
text: Few-Shot Learning aims to learn a prediction model from very limited amount of labelled data (Lake et al., 2015). Specifically, given a K−shot, N−class data for a classification task, the aim is to learn a multi-class classification model for N− classes, with K−labeled training examples for each class. Here K is usually a small number (e.g. 1, or 5). Considered as one of the hallmarks of human intelligence (Lake et al., 2011), this topic has received considerable interest in recent years (Lake et al., 2015; Koch et al., 2015; Vinyals et al., 2016; Finn et al., 2017). Modern techniques solve this problem through meta-learning, using an episodic learning paradigm. The main idea is to use a labeled training dataset to effectively acquire prior knowledge, such that this knowledge can be transferred to novel tasks where few-shot learning is to be performed. Different from traditional transfer learning (Pan et al., 2010; Yosinski et al., 2014), here few-shot tasks are simulated using the labeled training data through episodes, in order to acquire prior knowledge that is specifically tailored for performing few-shot tasks. For example, given a set of labeled training data with a finite label space Ytrain, the epsiodic paradigm is used to acquire prior knowledge which is stored in a model. Each episode is generated i.i.d from an unknown task distribution τtrain. This model is then used to do a novel few shot classification task which is drawn from an unknown task distribution τtest. The test task comprises small amount of labeled data with a finite label space Ytest, and the sets Ytrain and Ytest are (possibly) mutually exclusive. Using this labeled data, and acquired prior knowledge, the goal is to predict the labels of all unlabeled instances in the test task.
A very restrictive assumption of existing meta-learning approaches for few-shot learning is that train and test tasks are drawn from the same distribution, i.e., τtrain = τtest. In this scenario, the metalearner’s objective is to minimize its expected loss over the tasks drawn from the task distribution τtrain. This assumption prohibits the use of meta-learning strategies for real-world applications, where training tasks with ample labeled data, and drawn from the same distribution as the test tasks are very unlikely to be available. Consider the case of a researcher or practitioner who wishes to train a prediction model for their own dataset where labeled data is very limited. It is unreasonable to assume that they would have a large corpus of labeled data for a set of related tasks in the same domain. Without this, they are not able to train effective few-shot models for their task. A more desirable option is to use the training tasks where ample training data is available, and adapt the
model to be effective on test tasks in a different domain. A possible way to tackle this problem could be through the use of domain adaptation techniques (Ganin et al., 2016; Hoffman et al., 2018) that address the domain shift between the training and test data. However, all of these approaches address the single-task scenario, i.e., Ytrain = Ytest, where the training data and test data are sampled from the same task but there is a domain shift at a data-level. This is in contrast to the meta-learning setting where the training data contains multiple tasks and the goal is to learn new tasks from test data, i.e., domain shift exists at a task-level and Ytrain ∩ Ytest = ∅. As a result, these domain adaptation approaches cannot be directly applied. We show an overview of different problem settings in Table 1.
In order to solve the few-shot learning problem under a domain shift we propose a novel meta-learning paradigm: Meta-Learning with Domain Adaptation (MLDA). Existing meta-learning approaches for few-shot learning use only the given training data to learn a model, and as a result they do not account for any domain shift between the training tasks and the few-shot test tasks. In contrast, we assume that the model has access to the unlabeled instances in the domain of the few-shot test tasks prior to the training procedure, and utilize these instances for incorporating the domain-shift information. We train the model under the episodic-learning paradigm, but in each episode we aim to train a model which achieves two goals: first the model should be good at few-shot learning, and second the model should be unaffected by a possible domain shift. The first goal is achieved by updating the model based on the few-shot learning loss suffered by the model for a given episode. The second goal is achieved by an adversarial domain adaptation approach, where a mapping is used which styles the training task to resemble the test task. In this way, the trained model can perform few-shot predictions on the test tasks, and achieve what we term task-level domain adaptation.
The episodic update is done via Prototypical Networks (Snell et al., 2017) (as a specific instantiation, though other approaches can be applied), where on a simulated few-shot task (a small support set behaves as training, and a query set behaves as test data), an embedding is produced for both support and query instances. The mean of support embedding of each class is the prototype, and query instances are labeled based on their distance to these prototypes. Based on the loss on these query instances, the embedding function is updated. For achieving invariance to domain shift, we follow the principle of adversarial domain adaptation, but we differ from the traditional approaches in that we are performing task-level domain adaptation, whereas they performed data-level domain adaptation. The early approaches to adversarial domain adaptation aimed at obtaining a feature embedding that was invariant to both the training domain and the test domain, as well as learning a prediction model in the training domain (Ganin et al., 2016). However, these approaches possibly learnt a highly unconstrained feature embedding (particularly when the embedding was very high dimensional), and were outperformed by GAN-based approaches (often used for image translation) (Taigman et al., 2017; Zhu et al., 2017; Hoffman et al., 2018). As a result we use a mapping function to style the training tasks to resemble test tasks, and optimize it using a GAN loss. The overall framework delivers a model that uses training tasks from one distribution to meta-learn a few-shot model for a task from another distribution. We perform extensive experiments to show the efficacy of the proposed method.

heading: 2 RELATED WORK

heading: 2.1 META-LEARNING FOR FEW-SHOT LEARNING
text: Few-Shot Learning refers to learning a prediction model from small amount of labeled data (Fei-Fei et al., 2006; Lake et al., 2011). Early approaches used a Bayesian model (Fei-Fei et al., 2006), or hand-designed priors (Lake et al., 2015). More recently, meta-learning approaches have become extremely successful for addressing few-shot learning (Vinyals et al., 2016; Finn et al., 2017). Instead of training a model directly on the few-shot data, meta-learning approaches use a corpus of labeled data, and simulate few-shot tasks on them to learn how to do few-shot learning. Some approaches follow the non-parametric principle, and develop a differentiable K−nearest neighbour solution (Vinyals et al., 2016; Shyam et al., 2017; Snell et al., 2017). The main concept is to learn an embedding space that is tailored for performing effective K-nearest neighbour. Oreshkin et al. (2018)
extend these approaches with metric scaling to condition the embedding based on the given task. Another category of meta-learning aims to learn how to quickly adapt a model in few gradient steps for a few-shot learning task (Finn et al., 2017; Ravi & Larochelle, 2017; Li et al., 2017). These optimization based approaches aim to learn an initialization from a set of training tasks, which can be quickly adapted (e.g. one-step gradient update) when presented with a novel few-shot task. Some other approaches consider using a "memory"-based approach (Santoro et al., 2016; Munkhdalai & Yu, 2017). There have also been approaches that try to enhance meta-learning performance through use of additional information. For example, Ren et al. (2018) use unlabeled data to develop semi supervised few-shot learning. Zhou et al. (2018) use external data to generate concepts, and performs meta-learning in the concept space. However, all of these approaches assume that the training tasks and testing tasks are drawn from the same distribution (τtrain = τtest). If there is a task-level domain shift, the above approaches will fail to perform few-shot learning on novel test tasks. Our approach of meta-learning with domain adaptation overcomes this domain shift, to perform few-shot learning on tasks in a different domain.

heading: 2.2 DOMAIN ADAPTATION
text: Domain adaptation has been studied extensively in recent years, particularly for computer vision applications (Saenko et al., 2010). The idea is to exploit labeled data in one domain (called source domain) to perform a prediction task in another domain (called the target domain), which does not have any labels (unsupervised domain adaptation). Most approaches employed two objectives: one to learn a prediction model in the source domain, and second to find an embedding space between the two domains that achieves domain invariance, thus making the model trained on the source domain applicable to the task in the target domain. In the era of deep learning, some early approaches aimed to align feature distribution in some embedding space using statistical measures (e.g. Maximum Mean Discrepancy) (Tzeng et al., 2014; Long et al., 2015). This was followed by several successful efforts for domain adaptation using an adversarial loss (Goodfellow et al., 2014). Ganin & Lempitsky (2015); Ganin et al. (2016) aimed to learn a feature embedding such that a domain classifier would not be able to distinguish whether the instance was drawn from the source or target domain. Consequent efforts tried to learn an embedding on the source data, from which an instance in the target domain could be reconstructed (Ghifary et al., 2016). Tzeng et al. (2017) proposed to train a model in the source domain, and using a GAN loss try to embed the target domain to the same feature distribution (using a GAN loss) as the (now fixed) source domain. Another line of work using GAN-loss is for image-toimage translation, where images in one domain are mapped to appear like images in another domain (Taigman et al., 2017; Liu et al., 2017). Most of these approaches have demonstrated application to domain adaptation tasks as well. Another recently introduced concept is cycle consistency which first maps an instance from the source to target, and then maps this synthetic instance back to the source to get back to original instance (Zhu et al., 2017; Kim et al., 2017; Yi et al., 2017), and this concept has been extended for domain adaptation as well (Hoffman et al., 2018). All of these approaches aim to solve the same task in both domains (i.e., the label space is the same in both domains). They perform domain adaptation at the data-level (and not the task level). This means that they cannot solve a new task with a different label space. In contrast our approach performs a task-level domain adaptation, and can solve new tasks.
There have been some efforts at the intersection of few-shot (and meta-learning) and domain adaptation. Motiian et al. (2017) consider supervised domain adaptation, which is similar to unsupervised domain adaptation setting, except that few labeled instances in the target domain are available. Like the previous approaches, it can not be used for a novel task with a different label space. Kang & Feng (2018)’s problem setting resembles traditional unsupervised domain adaptation, except that the model training is done using a meta-learning principle. Li et al. (2018) use meta-learning to address domain generalization where a single trained model for a given task, can be applied to any new domain with a different data distribution. They too consider solving the same task in a new domain, and do not consider the few-shot setting. A closely related work is Domain Adaptive Meta Learning (Yu et al., 2018), but their problem setting is different (which is more suitable for the problem they address: imitation learning) from what we address in this paper. They consider the scenario where a task has training data drawn from one domain and test data drawn from another domain (independent of whether it has been drawn from τtrain or τtest). Thus, they do not violate τtrain = τtest. In their simulated task, ample labeled training data is available for both the source and target domains. In contrast, we consider the scenario where the training tasks and test tasks are drawn from different distributions, and we have very limited labeled data for test tasks (tasks in the target domain).

heading: 3 META-LEARNING WITH DOMAIN ADAPTATION (MLDA)
text: Formally, let X be an input space and Y be a discrete label space. Let D be a distribution over X ×Y . During meta-training, the meta-learner has access to a large labeled dataset Strain that typically contains thousands of instances for a large number of classes C. At the i-th iteration of episodic learning paradigm, the meta-learner samples a K−shot N -class classification task Ti from Strain, which contains a small “training” (assumed to have labels for all instances for this task) set Ssupporti (with K examples from each class) and a “test” (assumed to not have labels of any instances for this task) set Squeryi . Both S support i and and S query i are assumed to be generated from an unknown sample distribution Ssupporti ∼ Dmi and S query i ∼ Di respectively, where m = NK denotes the number of instances. The sample distribution Di are assumed to be generated i.i.d. from an unknown task distribution τtrain, i.e, ((Dm,D) ∼ τtrain). It then computes conditional probabilities p(y|x, Ssupporti ) for every point (x; y) in the test set S query i . Based on these predictions, meta-learner incurs a loss L(p(y|x, Ssupporti ), y) for each point in the current S query i . The meta-learner then back-
propagates the gradient of the loss ∑
(x,y)∈Squery L(p(y|x, Ssupport), y) for updating the model. In the meta-testing phase, the resulting meta-learner is used to solve the novel K−shot N -class classification tasks, which are assumed to be generated i.i.d. from an unknown task distribution τtest. The labeled training set and unlabeled test examples are given to the classification algorithm and the algorithm outputs class probabilities.
Existing meta-learning approaches assume that both training and testing tasks are drawn from the same distribution, i.e., τtrain = τtest. However, this may not be the case in several real-world scenarios (i.e., τtrain 6= τtest ). Consider the case of a researcher who wants to do few-shot classification on a newly collected image recognition dataset (task drawn from τtest). This researcher must now find a large amount of labeled data from which tasks can be drawn from the same task distribution (τtest), failing which the researcher does not have a clear approach to acquire the relevant prior knowledge. The alternative is for the researcher to find tasks drawn from a different distribution, where ample labeled data is available, and perform task-level domain adaptation in order to learn a few-shot model suitable for their own task. Thus, we make a distinction between the task drawn from τtrain and τtest, as (Dmtrain,Dtrain) ∼ τtrain and (Dmtest,Dtest) ∼ τtest. (Dmtrain,Dtrain) and (Dmtest,Dtest) may have tasks whose instances are drawn from different domains (xtrain ∈ X train and xtest ∈ X test respectively), and may also have a mutually exclusive discrete label space (e.g. Ytrain ∩ Ytest = ∅). Our overall goal is to learn a meta-learner that can utilize tasks drawn from τtrain to acquire a good prior for few-shot learning, and overcome the task-level domain-shift in order to learn unobserved few-shot tasks drawn from τ test. The general setting can be seen in Figure 1. Next, we briefly describe our proposed few-shot learning approach under task-level domain shift.
Data from which Train Tasks are drawn from 𝝉𝒕𝒓𝒂𝒊𝒏 Data from which Test Tasks are drawn from 𝝉𝒕𝒆𝒔𝒕

heading: 3.1 FEW-SHOT LEARNING IN NEW DOMAINS USING MLDA
text: Here, we give the overview of our proposed learning paradigm: Meta Learning with Domain Adaptation (MLDA). We have two objectives that need to be optimized simultaneously. First, we want to learn a feature extractor that can learn discriminative features which can be used for fewshot learning on novel tasks. Second, we want these features to be invariant to the train task distribution and test task distribution, i.e., for a task Ti ∼ (Dmtrain,Dtrain), we want to adapt it to resemble a task drawn from (Dmtest,Dtest). Specifically, in the meta-learning phase, we consider a feature extractor F : X train → Rd which takes an input instance x ∈ X train and returns a d−dimensional embedding. This feature extractor in turn is a composition function F(x) = F̂(G(x)), where G : X train → X test, and F̂ : X test → Rd. The feature extractor F is trained to learn a representation suitable for few-shot learning (by optimizing objective Lfs). G aims to achieve task-level domain invariance by translating instances from domain X train to instances in domain X test. G is trained using an adversarial loss, inspired by recent success of GAN-based (Goodfellow et al., 2014) domain adapation methods (Tzeng et al., 2017; Zhu et al., 2017; Hoffman et al., 2018). G (along with the corresponding discriminator D) is trained to achieve domain adaptation (by optimizing objective Lda). We also use a mapping G′ : X test → X train to obtain cyclic consistency, wherein we try to translate generated instance G(x) to produce the original instance x. The overall objective function is given by:
min F̂,G,G′ max D Lfs + Lda (1)
Note that Lfs is optimized using only labeled training data of tasks drawn from τtrain and Lda is optimized using unlabeled data of tasks drawn from both τtrain and τtest. The overall framework can be seen in Figure 2. Next, we will describe motivation and technical details of these components.

heading: 3.2 FEW-SHOT LEARNING
text: There have been several approaches for few-shot learning via meta-learning in literature (Vinyals et al., 2016; Finn et al., 2017; Snell et al., 2017). In principle, our proposed paradigm is agnostic to any of these approaches. In our work, we follow a recent state of the art approach: Prototypical Networks (Snell et al., 2017) to instantiate our framework for meta learning with domain adaptation. For a given task Ti ∼ (Dmtrain,Dtrain), Prototypical Networks use a feature extractor F : X train → Rd to
compute a d−dimensional embedding for each instance. Using this feature extractor, the mean vector embedding is computed for each class cn for n = 1, . . . , N , which are the prototypes of each class:
cn = 1
Ssupportn ∑ (xi,yi)∈Ssupportn F(xi) (2)
For a given query instance x, Prototypical Network will produce a probability distribution over the classes using:
p(y = n|x) = exp(−dist(F(x), cn))∑N (j=1) exp(−dist(F(x), cj))
(3)
where dist : Rd × Rd → [0,∞) is a function measuring the distance between the embeddings of a query instance and a class prototype. The few-shot loss Lfs is the negative log-probability:
Lfs = − log p(y = k|x) (4) This loss is evaluated on the query set Squeryi , and backpropagated to update the parameters of feature extractor F. In this setup, F does not account for a domain shift between τtrain and τtest. Consequently, we use F(x) = F̂(G(x)), where G will help incorporate the domain shift information.

heading: 3.3 ADVERSARIAL TASK-LEVEL DOMAIN ADAPTATION
text: Here, we describe how to perform task-level domain adaptation and learn the mapping parameters G.

heading: 3.3.1 GAN LOSS AND CYCLE CONSISTENCY
text: We use the GAN loss (Goodfellow et al., 2014) to learn the mapping G : X train → X test, and its corresponding discriminator D. The objective function is denoted as:
LGAN (G, D,X train,X test) = Extest∼Dtest [logD(xtest)] + (5) Extrain∼Dtrain [log(1−D(G(x train)))]
Here G tries to generate instances that appear to be similar to the instances in domain X test, and D tries to distinguish between translated instances G(xtrain)and the real samples xtest. This objective is minimized under the parameters of G and maximized under the parameters of D. This effectively leads to translating tasks drawn from τtrain to be translated such that they are indistinguishable from tasks drawn from τtest.
Despite the ability of adversarial networks to produce an output indistinguishable from the test domain X test, with a large capacity, it is not inconceivable for the network to map the same set of input images in the train domain X train to any random permutation of images in the test domain (a form of overfitting). This is because the objective is highly unconstrained. As a result, we use a cycle-consistency loss (Zhu et al., 2017; Hoffman et al., 2018), which uses a new mapping G′ : X test → X train which will take as input the translated instance G(x) and try to invert this function to get back the original instance, i.e., x→ G(x)→ G′(G(x)) ≈ x. Using an L1-loss the task-cycle-consistency loss is given as:
Lcycle = Extrain∼Dtrain [||G ′(G(x))− x||1] (6)
Combining the objectives from equation 5 and equation 6, we get the domain adaptation objective as Lda = LGAN + Lcycle.

heading: 3.3.2 ADDITIONAL IMPROVEMENTS
text: The objective in equation 1 is the basic objective of our proposed framework. We also consider two advanced variants that help improve the performance of the domain adaptation. First, we consider an identity loss where we encourage G to behave like an identity mapping when it receives an instance from X test, thereby behaving as an identity function for a test task. We also introduce a reverse direction mapping to map instances from test tasks X test → X train, and a corresponding cycle loss to reconstruct back the instance in X test. All these objectives get tied together to deliver an appropriate task-level domain adaptation for a few-shot learning task. These improvements follow from state of the art image-to-image translation techniques (Taigman et al., 2017; Zhu et al., 2017).

heading: 4 EXPERIMENTS

heading: 4.1 EXPERIMENTAL SETTING
text: The setting we follow is: we have meta-training data in the original domain, unlabeled data in the target domain which is used for domain adaptation, and the meta-test data, from which test tasks will be drawn. There is no overlap between the data used for domain adaptation, and the meta-test data. Being a new problem setting, there have not been any approaches in literature directly addressing this problem. In order to be comparable, we adapt some of the techniques in Meta-Learning and Domain Adaptation, to make them suitable for our setting. Specifically, we consider 3 state of the art domain adaptation baselines RevGrad (Ganin et al., 2016), ADDA (Tzeng et al., 2017), and CyCADA (Hoffman et al., 2018). These baselines are trained on the meta-train data to learn a multi-class classifier and the unlabeled target domain data is used for domain adaptation. During meta-testing, these models are used as feature extractors, and K-NN is performed for prediction. We consider two meta-learning baselines MAML (Finn et al., 2017) and Prototypical Networks (Snell et al., 2017), which are trained on meta-train data; however these approaches do not consider the domain-shift issues. We construct a baseline that combines meta-learning with task-level domain shift. It is a combination of Prototypical Networks (Snell et al., 2017) with Gradient Reversal (Ganin et al., 2016), which we call Meta-RevGrad. Meta-RevGrad jointly optimizes PN-loss and a domain-confusion loss at the feature level where the embedded features of training tasks are made to appear like embedded features of test tasks resulting in the objective: λLfs + (1 − λ)LRevGrad. Readers are refered to Ganin et al. (2016) for greater detail on LRevGrad. Here λ ∈ (0, 1) is a trade-off parameter between few-shot performance and domain adaptation. We try several values of λ = 0.9, 0.8, 0.7, 0.6, 0.5 and report the best result. For our proposed method for Meta Learning with Domain Adaptation: MLDA, we consider three variants: the basic version MLDA based on equation 1; MLDA+idt, which considers the previous objective and an identity loss (see Section 3.3.2); and MLDA+idt+revMap which adds an additional component of (reverse) mapping testing tasks to train tasks (see Section 3.3.2).
Most of our code was implemented in PyTorch (Paszke et al., 2017) (for both baselines and proposed method). We follow the same model size and parameter setting for our models as the ones used in prior work for Prototypical Networks (Snell et al., 2017) and CycleGAN (Zhu et al., 2017). Jointly optimizing the objective in equation 1 can be very noisy (oscillating) and slow. To ease the implementation, we follow a two-step procedure for the optimization. We first optimize the objective with respect to all parameters except F̂. Then, all of these parameters are frozen, and F̂ is learned. Another issue with the GAN-based training is that the task generator lacks randomness, and always maps the same input task to the same output task (which can limit the meta-learning efficacy if the test-task domain is very diverse). To address this, during the GAN training we store intermediate models (e.g. a model saved after every epoch) and generate tasks using each of these models. This is similar to Snapshot Ensembles (Huang et al., 2017), where multiple models under one training cycle to increase robustness. We provide greater detail on the implementations in the appendix.

heading: 4.2 RESULTS ON CHARACTER RECOGNITION
text: We use Omniglot dataset (popularly used for benchmarking few-shot classification). The dataset comprises over 1,600 hand written characters, with 20 instances each. The dataset was further expanded by applying rotations. Inspired by a popular domain adaptation benchmark: MNIST to MNIST-M (Ganin et al., 2016), we design a new benchmark, suited for the few-shot learning under domain-shift: Omniglot to Omniglot-M. Omniglot-M is constructed in the same manner as MNIST-M, i.e., by randomly blending different Omniglot characters with different color background from BSDS500 (Arbelaez et al., 2011). We follow the same meta-train and meta-test split as previous approaches, (but meta-train and meta-test are in different domains). Unlabeled data from validation split (mutually exclusive with meta-test) is used for domain adaptation. We consider Omniglot to Omniglot-M, and Omniglot-M to Omniglot. We evaluate 1-shot, 5-class and 5-shot, 5-class tasks.
The results can be seen in Table 2. We can see that the basic domain adaptation and meta-learning approaches are not able to get a very good performance, as domain adaptation approaches are not suitable for few-shot learning, and meta-learning methods do not account for domain-shift. Meta-RevGrad is able to occasionally offer some improvement over the basic techniques, but is outperformed by our proposed MLDA. In general, MLDA can outperform all the baselines by a big margin. This can be observed in the case of both Omniglot→ Omniglot-M and Omniglot-M→
Omniglot. Similar performance trends are observed for both 1-shot and 5-shot tasks. Within the variants of MLDA, we see that identity loss, and the reverse mappings are able to offer substantial boost to the overall performance, indicating better quality task-level domain adaptation.

heading: 4.3 RESULTS ON OFFICE-HOME DATASET
text: We conducted similar experiments using Office-Home Dataset (Venkateswara et al., 2017), in particular data from two domains: Clipart and Product. There are a total of 65 classes, and we randomly split them into 3 sets, labelled data for meta-train (25 classes), unlabeled data for domain adaptation (20 classes), and the meta-test data (20 classes). All images were resized to 84x84x3, and all models were trained from scratch (pretrained models were not used). We consider Clipart to Product, and Product to Clipart. We evaluate 1-shot, 5-class and 5-shot, 5-class tasks.
The results can be seen in Table 3. The observations here are similar in trend to those observed for the character recognition experiments. The basic meta-learning approaches are quite poor (even though better than random). Meta-RevGrad can offer some improvement, and MLDA gives an even better performance. The performance trend is fairly consistent for both 1-shot and 5-shot tasks.

heading: 5 CONCLUSION
text: In this paper we investigated a novel problem setting: Meta-Learning for few-shot learning under task-level domain shift. Existing meta learning paradigm for few-shot learning was designed under the assumption that both training tasks and test tasks were drawn from the same distribution. This may not be the case for real world applications, where researchers may not find ample labeled data to simulate training tasks to be drawn from the same distribution as their test tasks. To alleviate this, we propose a meta learning with domain adaptation paradigm, which performs meta-learning by incorporating few-shot learning and task-level domain adaptation unified into a single meta-learner. We instantiate our few-shot model with Prototypical Networks and adopt an adversarial approach for task level domain adaptation. We conduct several experiments to validate the proposed ideas.

heading: 6 APPENDIX: DATASET CONSTRUCTION

heading: 6.1 OMNIGLOT↔ OMNIGLOT-M
text: Here we show the details of the original Omniglot dataset and the statistical details, and some examples of how the characters look in a different domain. The meta-train, meta-test, and domain adaptation split of classes we used are based on the same split used in prior work. There is no overlap of classes or instances among the three sets, i.e., they are all mutually exclusive both at instance and class-level.

heading: 6.2 CLIPART↔ PRODUCT
text: Here we show details of Office-Home dataset and some examples of how classes look in a different domains (Clipart and Product). The meta-train, meta-test, and domain adaptation split of classes used by us is shown in Tables 5 and 6.

heading: 7 APPENDIX: MODEL CONFIGURATION AND TRAINING
text: For MLDA, we followed training procedures adopted similar to Zhu et al. (2017) and Snell et al. (2017). Specifically, for CycleGAN, we changed the parameters related to image dimensions (scaling and cropping pre-processing) to keep the generated image size fixed to the original size i.e. 28× 28 for Omniglot/Omniglot-M and 84× 84 for OfficeHome Clipart/Product. The generative networks are the same as the original work (Zhu et al., 2017), each including two stride-2 convolutions with residual blocks, and two fractionally-strided convolutions with stride 12 . For all experiments, we used 6 blocks to generate images. We initialized the learning rate to 0.0002 and kept this learning rate for training till 100 epochs. The model after each epoch was used to translate source task to
target task. Weights were initialized with Gaussian distribution with mean 0 and standard deviation 0.02. We use the Adam solver with a batch size of 1. We also modified the loss function for diffent settings of MLDA. Specifically, for MLDA, we removed the losses related to target→ source (B→ A) mapping and set λidt = 0. For MLDA+idt, we set λidt = 0.1. For MLDA+idt+revMap, we kept the loss function the same as the original CycleGAN.
For Prototypical Networks, we followed the best hyperparameter settings in Snell et al. (2017). We used the same embedding architecture in the original work, including four convoluational blocks, each of which comprises a 64-filter 3× 3 convolution, batch normalization layer, ReLU activation, and 2× 2 max-pooling layer. This results in 64-dimensional output space for Omniglot/Omniglotm and 1600-dimensional output space for HomeOffice Clipart/Product. For Omniglot/Omniglotm experiments, the learning rate was set to 0.001 and reduced by half every 2K iterations, starting from iteration 2K. The network is trained for a total of 20K iterations. For OfficeHome Product/Clipart experiments, we initialized the learning rate to 0.001 and decayed the learning rate by half every 25K iterations, starting from iteration 25K. The model is trained up to 100K iterations. We also use Adam solver to optimize the networks. Following Snell et al. (2017), we chose squared Euclidean distance to perform kNN classification as this metric showed superior performance in prior work.
For all the baselines, we reused the official code and ran them with default hyperparameters. We only modified parameters to make the models compatible with the image resolution and number of classes in Omniglot/Omniglot-M and Product/Clipart datasets. In all experiments, we set Nc classes and NS support points per class identical at training and test-time. We also fixed 15 query points per class per episode in all experiments. We computed the classification accuracy by averaging over 600 randomly generated episodes from the Meta-test set.

Review summaries:
The authors consider the few-shot / meta-learning scenario in which the test set of interest is drawn from a different distribution from the training set. This scenario is well-motivated by the "researcher example" given throughout the paper. The authors assume access to a large unlabelled set in test (target) domain, and a large labelled (few-shot) set in the source domain. Thus, the paper is concerned with unsupervised version of the meta-learning problem under domain shift (i.e., a large amount of data unlabelled are available from the target domain).