Z ERO - SHOT TASK ADAPTATION BY HOMOICONIC META - MAPPING
Anonymous authors
Paper under double-blind review
A BSTRACT
How can deep learning systems ﬂexibly reuse their knowledge?
Toward this goal, we propose a new class of challenges, and a class of architectures that can solve them.
The challenges are meta-mappings, which involve systematically transforming task behaviors to adapt to new tasks zero-shot.
The key to achieving these challenges is representing the task being performed in such a way that this task representation is itself transformable.
We therefore draw inspiration from functional programming and recent work in meta-learning to propose a class of
Homoiconic Meta-Mapping (HoMM) approaches that represent data points and tasks in a shared latent space, and learn to infer transformations of that space.
HoMM approaches can be applied to any type of machine learning task, including supervised learning and reinforcement learning.
We demonstrate the utility of this perspective by exhibiting zero-shot remapping of behavior to adapt to new tasks.
I NTRODUCTION
Humans are able to use and reuse knowledge more ﬂexibly than most deep learning models can (Lake et al., 2017; Marcus, 2018).
The problem of rapid learning has been partially addressed by meta-learning systems (Santoro et al., 2016; Finn et al., 2017; 2018; Stadie et al., 2018;
Botvinick et al., 2019, see also Section 7).
However, humans can use our knowledge of a task to ﬂexibly adapt when the task changes.
In particular, we can often perform an altered task zero-shot, that is, without seeing any data at all.
For example, once we learn to play a game, we can immediately switch to playing in order to lose, and can perform reasonably on our ﬁrst attempt.
One fundamental reason for this is that humans are aware of what we are trying to compute and why.
This allows us to adapt our task representations to perform an altered task.
By contrast, most prior work on zero-shot learning relies on generating a completely new representation for a new task, e.g. from a natural language description (Socher et al., 2013; Oh et al., 2017, e.g.). These systems must therefore throw away much of their prior knowledge of the task and regenerate it from scratch, rather than just transforming what needs to be transformed.
Other approaches use relationships between tasks as an auxiliary learning signal (Yao et al., 2019; Pal and Balasubramanian, 2019, e.g.), but cannot adapt to a new task by transforming their task representations.
To address this, it is necessary to represent tasks in a transformable space.
This can grant the ability to rapidly and precisely adapt behavior to a new task.
In this paper, we propose a new class of tasks based on this idea: meta-mappings, i.e. mappings between tasks (see below).
Meta-mappings allow zero-shot performance of a new task based on its relationship to old tasks.
To address the challenge of performing meta-mappings, we propose using architectures which essentially take a functional perspective on meta-learning, and exploit the idea of homoiconicity.
(A homoiconic programming language is one in which programs in the language can be manipulated by programs in the language, just as data can.)
By treating both data and task behaviors as functions, we can conceptually think of both data and learned task behaviors as transformable.
This yields the ability to not only learn to solve new tasks, but to learn how to transform these solutions in response to changing task demands.
We demonstrate that our architectures can ﬂexibly remap their behavior to address the meta-mapping challenge.
By allowing the network to recursively treat its task representations as data points, and transform them to produce new task representations, our approach is able to achieve this ﬂexibility parsimoniously.
We suggest that approaches like ours will be key to building more intelligent and ﬂexible deep learning systems.
M ETA - MAPPING
We propose the meta-mapping challenge.
We deﬁne a meta-mapping as a task, or mapping, that takes a task as an input, output, or both.
These include mapping from tasks to language (explaining), mapping from language to tasks (following instructions), and mapping from tasks to tasks (adapting behavior).
While the ﬁrst two categories have been partially addressed in prior work (e.g. Hermann et al., 2017; Co-Reyes et al., 2019), the latter is more novel.
(We discuss the relationship between our work and prior work in Section 7.)
This adaptation can be cued in several ways, including examples of the mapping (after winning and losing at poker, try to lose at blackjack) or natural-language instructions (“try to lose at blackjack”).
We argue that task-to-task meta-mappings are a useful way to think about human-like ﬂexibility, because a great deal of our rapid adaptation is from a task to some variation on that task.
For example, the task of playing go on a large board is closely related to the task of playing go on a small board.
Humans can exploit this to immediately play well on a different board, but deep learning models generally have no way to achieve this.
We can also adapt in much deeper ways, for example fundamentally altering our value function on a task, such as trying to lose, or trying to achieve some orthogonal goal.
While meta-learning systems can rapidly learn a new task from a distribution of tasks they have experience with, this does not fully capture human ﬂexibility.
Given appropriate conditioning (see below), our architecture can use meta-mappings to adapt to substantial task alterations zero-shot, that is, without seeing a single example from the new task (Lake et al., 2017).
Achieving this ﬂexibility to meta-map to new tasks will be an important step toward more general intelligence – intelligence that is not limited to precisely the training tasks it has seen.
H OMOICONIC META - MAPPING (H O MM) ARCHITECTURE
To address these challenges, we propose HoMM architectures, composed of two components:
Input/output systems: domain speciﬁc encoders and decoders (vision, language, etc.)
that map into a shared embedding space Z . 2.
A meta-learning system that a) learns to embed tasks into the shared embedding space Z , b) learns to use these task embeddings to perform task-appropriate behavior, c) learns to embed meta-mappings into the same space, and d) learns to use these meta-mapping embeddings to transform basic task embeddings in a meta-mapping appropriate way.
These architectures are homoiconic because they have a completely shared Z for individual data points, tasks, and meta-mappings.
This parsimoniously allows for arbitrary mappings between these entities.
In addition to basic tasks, the system can learn to perform meta-mappings to systematically alter task behavior based on relationships to other tasks.
That is, it can transform task representations using the same components it uses to transform basic data points.
(See also Appendix E.1.)
Without training on meta-mappings, of course, the system will not be able to execute them well.
However, as we will show, if it is trained on a broad enough set of such mappings, it will be able to generalize to new instances drawn from the same meta-mapping distribution.
For instances that fall outside its data distribution, or for optimal performance, it may require some retraining, however.
This reﬂects the structure of human behavior – we are able to adapt rapidly when new knowledge is relatively consistent with our prior knowledge, but learning an entirely new paradigm (such as calculus for a new student) can be quite slow (cf.
Kumaran et al., 2016; Botvinick et al., 2019).
More formally, we treat functions and data as entities of the same type.
From this perspective, the data points that one function receives can themselves be functions 1 .
The key insight is that then our architecture can transform data points 2 to perform basic tasks (as is standard in machine learning),
[Figure]
at the next level of abstraction, when the same networks M and H are used to transform function embeddings based on examples of a meta-mapping (b).
To evaluate meta-mapping performance, a probe embedding of a held-out function is transformed by the architecture to yield a predicted embedding for the transformed task.
The performance of this predicted embedding is evaluated by moving back down a level of abstraction and evaluating on the actual target task (c).
Because the function embedding is predicted by a transformation rather than from examples, new tasks can be performed zero-shot.
( M and H are learnable deep networks, and F z is a deep network parameterized by H conditioned on function embedding z .
Input and output encoders/decoders are omitted for simplicity.
See the text and Appendix F.2 for details.)
but it can also transform these task functions to adapt to new tasks.
This is related to the concepts of homoiconicity, deﬁned above, and higher-order functions.
Under this perspective, basic tasks and meta-mappings from task to task are really the same type of problem.
The functions at one level of abstraction (the basic tasks) become inputs and outputs for higher-level functions at the next level of abstraction (meta-mapping between tasks).
Speciﬁcally, we embed each input, target, or mapping into a shared representational space Z .
This means that single data points are embedded in the same space as the representation of a function or an entire dataset.
Inputs are embedded by a deep network I : input → Z .
Model outputs are decoded from Z by O : Z → output.
Target outputs are encoded by T : targets → Z .
Given this, the task of mapping inputs to outputs can be framed as trying to ﬁnd a transformation of the representational space that takes the (embedded) inputs from the training set to embeddings that will decode to the target outputs.
These transformations are performed by a system with the following components (see Fig. 1): M : { ( Z, Z ) , ... }
→ Z – the meta network, which collapses a dataset of (input embedding, target embedding) pairs to produce a single function embedding.
H : Z → parameters – the hyper network, which maps a function embedding to parameters.
F : Z → Z – the transformation, implemented by a deep network parameterized by H .
Basic meta-learning: To perform a basic task, input and target encoders ( I and T ) are used to embed individual pairs from an example dataset D 1 , to form a dataset of example (input, output) tuples (Fig. 1a).
These examples are fed to M , which produces a function embedding (via a deep neural network, with several layers of parallel processing across examples, followed by an elementwise max across examples, and several more layers).
This function embedding is mapped through the hyper network H to parameterize F , and then F is used to process a dataset of embedded probe inputs, and O to map the resultant embeddings to outputs.
This system can be trained end-to-end on target outputs for the probes.
Having two distinct datasets forces generalization at the meta-learning level, in exactly the same way as standard meta-learning algorithms learn to generalize.
More explicitly, suppose we have a dataset of example input, target pairs ( D 1 = { ( x 0 , y 0 ) , ... } ), and some input x from a probe dataset D 2 .
The system would predict a corresponding output ˆ y as:
[Equation]
where F z func is the meta-learner’s representation for the function underlying the examples in D 1 :
F z func is parameterized by H (cid:0) z func (cid:1) , where z func =
M ( { ( I ( x 0 ) , T ( y 0 )) , ... } )
Then, given some loss function L ( y, ˆ y ) deﬁned on a single target output y and an actual model output
ˆ y , we deﬁne our total loss computed on the probe dataset D 2 as:
[Equation]
The system can then be trained end-to-end on this loss to adjust the weights of T , H , M , O , and I .
That is, the meta-learning training procedure optimizes the system for generalizing the function implied by the examples it sees, in order to respond appropriately to probe inputs.
As in training a standard meta-learning model, these probes are held-out from the meta-network, but the labels are still used to encourage the system to meta-learn to respond appropriately to new inputs.
Other data points are held-out entirely during training, and only used for evaluation, see Appendix A.1 for some detailed description.
See Appendix F.2 for further details on the architecture and hyper-parameters.
Meta-mapping: The fundamental insight of our paper is to show how basic tasks and metamappings can be treated homogenously, by allowing the network to transform its task representations like data (see Fig. 1b,c).
That is, we propose to transform a prior task representation in order to perform a related new task zero-shot.
The relationship by which the prior task embedding should be transformed to perform the new task is speciﬁed by example tuples of (input, output) task embeddings.
This is precisely analogous to how a basic task is speciﬁed in terms of (input, output) embeddings of data points, except that the embeddings now represent tasks that are being transformed, rather than individual data points.
Thus from the perspective of our architecture, learning a meta-mapping between tasks is exactly analogous to learning a basic task.
Anything that is embedded in Z can be transformed using the same system.
Because tasks are embedded in Z for basic meta-learning, this allows for meta-mappings using exactly the same M and H that we use for basic tasks.
Just as we would take a set of paired embeddings of data points for a basic task, and use them to compute a function embedding for that task, we can take a set of paired function embeddings representing a meta-mapping, and use them to create an embedding for that meta-mapping.
We can then use this meta-mapping embedding to transform the embedding of another basic task.
We can thus behave zero-shot on a novel task based on its relationship to a prior task.
For example, suppose we have an embedding z game 1 ∈ Z for the task of playing some game, and we want to switch to trying to lose this game.
We can generate a meta-mapping embedding z meta ∈ Z from examples of embeddings generated by the system when it is trying to win and lose various other games: z meta =
M ( { (( z game 2 , z game 2 ,lose ) , ... } ) .
We can generate a new task embedding ˆ z game 1 ,lose ∈ Z :
[Equation]
[Table]
1 ) where F z meta is parameterized by H ( z meta )
This ˆ z games 1 ,lose can be interpreted as the system’s guess at a losing strategy for game 1.
To train a meta-mapping, we minimize the (cid:96) 2 loss in the latent space betwen this guessed embedding and the embedding of the target task 3 .
Whether or not we have such a target embedding, we can [Figure] evaluate how well the system loses with this ˆ z game 1 ,lose strategy, by stepping back down a level of abstraction and actually having it play the game via this embedding (Fig. 1c).
This is how we evaluate meta-mapping performance – evaluating the loss of transformed task embeddings on the respective target tasks.
Note that this allows for zero-shot performance of the new task, because it simply requires transforming a prior task embedding.
Alternatively, we could map from language to a meta-mapping embedding, rather than inducing it from examples of the meta-mapping.
This corresponds to the human ability to change behavior in response to instructions.
The key feature of our architecture – the fact that tasks, data, and language are all embedded in a shared space – allows for substantial ﬂexibility within a uniﬁed framework.
Furthermore, our approach is parsimonious.
Because it uses the same meta-learner for both basic tasks and meta-mappings, this increased ﬂexibility does not require any added parameters.
L EARNING MULTIVARIATE POLYNOMIALS
As a proof of concept, we ﬁrst evaluated the system on the task of learning polynomials of degree ≤ 2 in 4 variables (i.e. the task was to regress functions of the form p : R 4 → R where p ∈ P 2 ( R ) , though the model was given no prior inductive bias toward polynomial forms).
For example, if p ( w, x, y, z ) = x , the model might see examples like ( − 1 , 1 , 1 , 1; 1) and (0 . 7 , 2 . 1 , 1 . 3 , − 4; 2 . 1) , and be evaluated on its output for points like ( − 1 , − 1 . 3 , 0 . 5 , 0 . 3) .
This yields an inﬁnite family of baselevel tasks (the vector space of all such polynomials), as well as many families of meta-mappings over tasks (for example, multiplying polynomials by a constant, squaring them, or permuting their input variables).
This allows us to not only examine the ability of the system to learn to learn polynomials from data, but also to adapt its learned representations in accordance with these meta-tasks.
Details of the architecture and training can be found in Appendix F.
[Figure] Basic meta-learning: First, we show that the system is able to achieve the basic goal of learning a held-out polynomial from a few data points in Fig. 2a (with good sample-efﬁciency, see Supp.
Fig. Zero-shot adaptation by meta-mapping (task → task): Furthermore, the system is able to perform meta-mappings over polynomials in order to ﬂexibly reconﬁgure its behavior (Fig. 3a).
We train the system to perform a variety of mappings, for example switch the ﬁrst two inputs of the polynomial, add 3 to the polynomial, or square the polynomial.
We then test its ability to generalize to held-out mappings from examples, for example a held-out input permutation, or an unseen additive shift.
The system is both able to apply learned meta-mappings to held-out polynomials, and to apply held-out meta-mappings it has not been trained on, simply by seeing examples of the mapping.
A STOCHASTIC LEARNING SETTING : SIMPLE CARD GAMES
We next explored the setting of simple card games, where the agent is dealt a hand and must bet.
There are three possible bets (including “don’t bet”), and depending on the opponent’s hand the agent either wins or loses the amount bet.
This task doesn’t require long term planning, but does incorporate some aspects of reinforcement learning, namely stochastic feedback on only the action chosen.
We considered ﬁve games that are simpliﬁed analogs of various real card games (see Appendix F.1.2).
We also considered several binary options that could be applied to the games, including trying to lose instead of trying to win, or switching which suit was more valuable.
These are challenging manipulations, for instance trying to lose requires completely inverting a learned Q -function.
[Figure]
In order to adapt the HoMM architecture, we made a very simple change.
Instead of providing the system with (input, target) tuples to embed, we provided it with (state, action, reward) tuples, and trained it to predict rewards for each bet in each state.
(A full RL framework is not strictly necessary here because there is no temporal aspect to the tasks; however, because the outcome is only observed for the action you take, it is not a standard supervised task.)
The hand is explicitly provided to the network for each example, but which game is being played is implicitly captured in the training examples, without any explicit cues
That is, the system must learn to play directly from seeing a set of (state, action, reward) tuples which implicitly capture the structure and stochasticity of the game.
We also trained the system to make meta-mappings, for example switching from trying to win a game to trying to lose.
Details of the architecture and training can be found in Appendix F.
Basic meta-learning: First, we show that the system is able to play a held-out game from examples in Fig. 2b.
We compare two different hold-out sets: 1) train on half the tasks at random, or 2) speciﬁcally hold out all the “losers” variations of the “straight ﬂush” game.
In either of these cases, the meta-learning system achieves well above chance performance (0) at the held out tasks, although it is slightly worse at generalizing to the targeted hold out, despite having more training tasks in that case.
Note that the sample complexity in terms of number of trained tasks is not that high, even training on 20 randomly selected tasks leads to good generalization to the held-out tasks.
Furthermore, the task embeddings generated by the system are semantically organized, see Appendix D.
Zero-shot adaptation by meta-mapping (task → task): Furthermore, the system is able to perform meta-mappings (mappings over tasks) in order to ﬂexibly reconﬁgure its behavior.
For example, if the system is trained to map games to their losers variations, it can generalize this mapping to a game it has not been trained to map, even if the source or target of that mapping is held out from training.
In Fig.
3b we demonstrate this by taking the mapped embedding and evaluating the reward received by playing the targeted game with it.
This task is more difﬁcult than simply learning to play a held out game from examples, because the system will actually receive no examples of the target game (when it is held out).
Furthermore, in the case of the losers mapping, leaving the strategy unchanged would produce a large negative reward, and chance performance would produce 0 reward, so the results are quite good.
A N EXTENSION VIA LANGUAGE
Language is fundamental to human ﬂexibility.
Often the examples of the meta-mapping are implicit in prior knowledge about the world that is cued by language.
For example, “try to lose at go” does not give explicit examples of the “lose” meta-mapping, but rather relies on prior knowledge of what losing means.
This is a much more efﬁcient way to cue a known meta-mapping.
In order to replicate this, we trained the HoMM system with both meta-mappings based on examples, and meta-mappings based on language.
In the language-based meta-mappings, a language input identifying the meta-mapping (but not the basic task to apply it to) is encoded by a language encoder, and then provided as the input to H (instead of an output from M ).
The meta-mapping then proceeds as normal — H parameterizes
F , which is used to transform the embedding of the input task to produce an embedding for the target.
This language-cued meta-mapping approach also yields good performance (Fig. 4).
However, examples of the meta-mapping are slightly better, especially for meta-mappings not seen during training, presumably because examples provide a richer description.
In the next section we show that using language to specify a meta-mapping performs better than using language to directly specify the target task. 6. W HY META - MAP FROM TASKS TO TASKS ? Why are meta-mappings between tasks useful?
To answer this, we consider various ways of adapting to a new task in Figure 5 (based on results from the cards domain, Section 5).
The standard metalearning approach would be to adapt from seeing examples of the new task, but this requires going out and collecting data, which may be expensive and does not allow zero-shot adaptation.
Alternatively, the system could perform the new task via a meta-mapping from a prior learned task, where the meta-mapping is either induced from examples of the meta-mapping, or from language. Finally, the system could perform a new task from language alone, if it is trained to map instructions to tasks. This is the more typical zero-shot paradigm (e.g. Romera-Paredes and Torr, 2015). To address this latter possibility, we trained a version of the model where we included training the language system to produce embeddings for the basic tasks (while simultaneously training the system on all the other objectives, such as performing the tasks from examples, in order to provide the strongest possible structuring of the system’s knowledge for the strongest possible comparison).
We compare this model’s performance at held-out tasks to that of systems learning from examples of the new task directly, or from meta-mapping, see Fig.
These results demonstrate the advantage of meta-mapping.
While learning from examples is still better given enough data, it requires potentially-expensive data collection and does not allow zeroshot adaptation.
Performing the new task from a language description alone uses only the implicit knowledge in the model’s weights, and likely because of this it does not generalize well to the difﬁcult held-out tasks.
Meta-mapping performs substantially better, while relying only on cached prior knowledge, viz.
prior task-embedding(s) and a description of the meta-mapping (either in the form of examples or natural language).
That is, meta-mapping allows zero-shot adaptation, like performing from language alone, but results in much better performance than language alone, by leveraging a richer description of the new task constructed using the system’s knowledge of a prior task and the new task’s relationship to it.
D ISCUSSION
Related work: There has been a variety of past work on zero-shot learning, mostly based on natural-language descriptions of tasks. For example, Larochelle et al.
(2008) considered the general problem of behaving in accordance with language instructions as simply asking a model to adapt its response when conditioned on different “instruction” inputs.
Later work explored zero-shot classiﬁcation based on only a natural language description of the target class (Socher et al., 2013;
Romera-Paredes and Torr, 2015; Xian et al., 2018), or of a novel task in a language-conditioned
RL system (Hermann et al., 2017).
Some of this work has even exploited relationships between tasks as a learning signal (Oh et al., 2017).
Other work has considered how similarity between tasks can be useful for generating representations for a new task (Pal and Balasubramanian, 2019), but without transforming task representations to do so.
(Furthermore, similarity is less speciﬁc than an input-output mapping, since it does not specify along which dimensions two tasks are similar.)
To our knowledge none of the prior work has proposed using meta-mapping approaches to adapt to new tasks by transforming task representations, nor has the prior work proposed a parsimonious homoiconic model which can perform these mappings.
Our work is an extrapolation from the rapidly-growing literature on meta-learning (e.g. Vinyals et al., 2016;
Santoro et al., 2016;
Finn et al., 2017; 2018; Stadie et al., 2018; Botvinick et al., 2019).
It is also related to the literature on continual learning, or more generally tools for avoiding catastrophic interference based on changes to the architecture (e.g. Fernando et al., 2017; Rusu et al., 2016), loss (e.g. Kirkpatrick et al., 2016; Zenke et al., 2017; Aljundi et al., 2019), or external memory (e.g. Sprechmann et al., 2018).
We also connect to a different perspective on continual learning in Appendix B. Recent work has also begun to blur the separation between these approaches, for example by meta-learning in an online setting (Finn et al., 2019).
Our work is speciﬁcally inspired by the algorithms that attempt to have the system learn to adapt to a new task via activations rather than weight updates, either from examples (e.g. Wang et al., 2016; Duan et al., 2016), or a task input (e.g. Borsa et al., 2019).
Our architecture builds directly off of prior work on HyperNetworks (Ha et al., 2016) – networks which parameterize other networks – and other recent applications thereof, such as guessing parameters for a model to accelerate model search (e.g. Brock et al., 2018;
Zhang et al., 2019), and meta-learning (Li et al., 2019; Rusu et al., 2019, e.g.)
In particular, recent work in natural language processing has shown that having contextually generated parameters can allow for zero-shot task performance, assuming that a good representation for the novel task is given (Platanios et al., 2017) – in their work this representation was evident from the factorial structure of translating between many pairs of languages.
Our work is also related to the longer history of work on different time-scales of weight adaptation (Hinton and Plaut, 1982; Kumaran et al., 2016) that has more recently been applied to meta-learning contexts (e.g. Ba et al., 2016; Munkhdalai and Yu, 2017; Garnelo et al., 2018) and continual learning (Hu et al., 2019, e.g.).
It is more abstractly related to work on learning to propose architectures (e.g. Zoph and Le, 2016; Cao et al., 2019), and to models that learn to select and compose skills to apply to new tasks (e.g. Andreas et al., 2016b;a; Tessler et al., 2016;
Reed and de Freitas, 2015; Chang et al., 2019).
In particular, some of the work in domains like visual question answering has explicitly explored the idea of building a classiﬁer conditioned on a question (Andreas et al., 2016b; 2017), which is related to one of the possible computational paths through our architecture.
Work in model-based reinforcement learning has also partly addressed how to transfer knowledge between different reward functions (e.g. Laroche and Barlier, 2017); our approach is more general.
Indeed, our insights could be combined with model-based approaches, for example our approach could be used to adapt a task embedding, which would then be used by a learned planning model.
There has also been other recent interest in task (or function) embeddings.
Achille et al.
(Achille et al., 2019) recently proposed computing embeddings for visual tasks from the Fisher information of the parameters in a model partly tuned on the task.
They show that this captures some interesting properties of the tasks, including some types of semantic relationships, and can help identify models that can perform well on a task.
Rusu and colleagues recently suggested a similar meta-learning framework where latent codes are computed for a task which can be decoded to a distribution over parameters (Rusu et al., 2019).
Other recent work has tried to learn representations for skills (e.g.
Eysenbach et al., 2019) or tasks (Hsu et al., 2019, e.g.) for exploration and representation learning.
Our perspective can be seen as a generalization of these that allows for remapping of behavior via meta-tasks.
While there have been other approaches to zero-shot task performance, to the best of our knowledge none of the prior work has explored zero-shot performance of a task via meta-mappings.
Future Directions: We think that the general perspective of considering meta-mappings will yield many fruitful future directions.
We hope that our work will inspire more exploration of behavioral adaptation, in areas beyond the simple domains we considered here.
To this end, we suggest the creation of meta-learning datasets which include information not only about tasks, but about the relationships between them.
For example, reinforcement learning tasks which involve executing instructions (e.g. Hermann et al., 2017; Co-Reyes et al., 2019) can be usefully interpreted from this perspective.
Furthermore, we think our work provides a novel perspective on the types of ﬂexibility that human intelligence exhibits, and thus hope that it may have implications for cognitive science.
We do not necessarily believe that the particular architecture we have suggested is the best architecture for addressing these problems, although it has a number of desirable characteristics.
However, the modularization of the architecture makes it easy to modify.
(We compare some variations in Appendix
E.)
For example, although we only considered task networks F that are feed-forward and of a ﬁxed depth, this could be replaced with a recurrent architecture to allow more adaptive computation, or even a more complex architecture (e.g. Reed and de Freitas, 2015; Graves et al., 2016).
Our work also opens the possibility of doing unsupervised learning over function representations for further learning, which relates to long-standing ideas in cognitive science about how humans represent knowledge (Clark and Karmiloff-Smith, 1993).
C ONCLUSIONS
A C LARIFYING META - MAPPING A. C LARIFYING HOLD - OUTS
There are several distinct types of hold-outs in the basic training of our architecture:
On each basic task, some of the data ( D 1 ) is fed to the meta-network as examples M while some probes ( D 2 ) is held out.
This encourages the model to actually infer the underlying function, rather than just memorizing the examples.
However, the probe labels are still used in training the system end-to-end, in order to encourage it to generalize.
There are also truly held-out tasks that the system has never seen in training.
These are the held-out tasks that we evaluate on at the end of training and that are plotted in the “Held out” sections in the main plots.
This applies analogously to the meta-mappings: each time a meta-mapping is trained, some basic tasks are used as examples while others are held out to encourage generalization.
There are also meta-mappings which have never been encountered during training, which we evaluate on at the end of training, those are the meta-mappings which are plotted in the “held out” section in the relevant plots.
We also evaluate the old (and new) meta-mappings on the new basic tasks that have never been trained.
A. A DEFINITIONAL NOTE
When we discussed meta-mappings in the main task, we equivocated between tasks and behaviors for the sake of brevity.
For a perfect model, this is somewhat justiﬁable, because each task will have a corresponding optimal behavior, and the sytem’s embedding of the task will be precisely the embedding which produces this optimal behavior.
However, behavior-irrelevant details of the task, like the color of the board, may not be embedded, so this should not really be thought of as a task-to-task mapping.
This problem is exacerbated when the system is imperfect, e.g. during learning.
It is thus more precise to distinguish between a ground-truth meta-mapping, which maps tasks to tasks, and the computational approach to achieving that meta-mapping, which really maps between representations which combine both task and behavior.
B C ONTINUAL LEARNING
Continual learning:
Although the meta-learning approach is effective for rapidly adapting to a new task, it is unreasonable to think that our system must consider every example it has seen at each inference step.
We would like to be able to store our knowledge more efﬁciently, and allow for further reﬁnement.
Furthermore, we would like the system to be able to adapt to new tasks (for which its guessed solution isn’t perfect) without catastrophically interfering with prior tasks (McCloskey and
Cohen, 1989).
A very simple solution to these problems is naturally suggested by our architecture.
Speciﬁcally, task embeddings can be cached so that they don’t have to be regenerated at each inference step.
This also allows optimization of these embeddings without altering the other parameters in the architecture, thus allowing ﬁne-tuning on a task without seeing more examples, and without interfering with performance on any other task (cf.
Rumelhart and Todd, 1993; Lampinen and McClelland, 2018).
This is like the procedure of Rusu et al.
(2019), except considered across episodes.
That is, we can see the meta-learning step as a “warm start” for an optimization procedure over embeddings that are cached in memory (cf.
Kumaran et al., 2016).
While this is not a traditional continual learning perspective, we think it provides an interesting perspective on the issue.
It might in fact be much more memory-efﬁcient to store an embedding per task, compared to storing an extra “importance” parameter for every parameter in our model, as in e.g. elastic weight consolidation (Kirkpatrick et al., 2016).
It also provides a stronger guarantee of non-interference.
To test this idea, we pre-trained the system on 100 polynomial tasks, and then introduced 100 new tasks.
We trained on these new tasks by starting from the meta-network’s “guess” at the correct task embedding, and then optimizing this embedding without altering the other parameters.
The results are shown in Fig.
The meta-network embeddings offer good immediate performance, and substantially accelerate the optimization process, compared to a randomly-initialized embedding (see supp.
Fig. 10 for a more direct comparison).
Furthermore, this ability to learn is due to training, not simply the expressiveness of the architecture, as is shown by attempting the same with an untrained network.
C S UPPLEMENTAL FIGURES
[Figure]
D C ARD GAME t -SNE
We performed t -SNE (Laurens van der Maaten and Hinton, 2008) on the task embeddings of the system at the end of learning the card game tasks, to evaluate the organization of knowledge in the network.
In Fig. 12 we show these embeddings for just the basic tasks.
The embeddings show systematic grouping by game attributes.
In Fig. 13 we show the embeddings of the meta and basic tasks, showing the organization of the meta-tasks by type.
E A RCHITECTURE EXPERIMENTS
In this section we consider a few variations of the architecture, to justify the choices made in the paper.
E. S HARED Z VS . SEPARATE TASK - EMBEDDING AND DATA - EMBEDDING SPACE
Instead of having a shared Z where data and tasks are embedded, why not have a separate embedding space for data, tasks, and so on?
There are a few conceptual reason why we chose to have a shared
Z , including its greater parameter efﬁciency, the fact that humans seem to represent our conscious knowledge of different kinds in a shared space (Baars, 2005), and the fact that this representation could allow for zero-shot adaptation to new computational pathways through the latent space, analogously to the zero-shot language translation results reported by Johnson and colleagues (Johnson et al., 2016).
In this section, we further show that training with a separate task encoding space worsens performance, see Fig.
This seems to primarily be due to the fact that learning in the shared Z accelerates and de-noises the learning process, see Fig. 15.
(It’s therefore worth noting that running this model for longer could result in convergence to the same asymptotic generalization performance.)
E. H YPER NETWORK VS . CONDITIONED TASK NETWORK
Instead of having the task network F parameterized by the hyper network H , we could simply have a task network with learned weights which takes a task embedding as another input.
Here, we show that this architecture fails to learn the meta-mapping tasks, although it can successfully perform the basic tasks.
We suggest that this is because it is harder for this architecture to prevent interference between the comparatively larger number of basic tasks and the smaller number of meta-tasks.
While it might be possible to succeed with this architecture, it was more difﬁcult in the hyper-parameter space we searched.
F D ETAILED METHODS F. D ATASETS F.1. P OLYNOMIALS
We randomly sampled the train and test polynomials as follows:
Sample the number of relevant variables ( k ) uniformly at random from 0 (i
e. a constant) to the total number of variables.
Sample the subset of k variables that are relevant from all the variables.
For each term combining the relevant variables (including the intercept), include the term with probability 0.5.
If so give it a random coefﬁcient drawn from N (0 , 2 . 5) .
The data points on which these polynomials were evaluated were sampled uniformly from [ − 1 , 1] independently for each variable, and for each polynomial.
The datasets were resampled everyepochs of training.
Meta-tasks:
For meta-tasks, we trained the network on 6 task-embedding classiﬁcation tasks:
• Classifying polynomials as constant/non-constant.
• Classifying polynomials as zero/non-zero intercept.
• For each variable, identifying whether that variable was relevant to the polynomial.
We trained on 20 meta-mapping tasks, and held out 16 related meta-mappings.
• Squaring polynomials (where applicable).
• Adding a constant (trained: -3, -1, 1, 3, held-out: 2, -2).
Multiplying by a constant (trained: -3, -1, 3, held-out: 2, -2).
• Permuting inputs (trained: 1320, 1302, 3201, 2103, 3102, 0132, 2031, 3210, 2301, 1203, 1023, 2310, held-out: 0312, 0213, 0321, 3012, 1230, 1032, 3021, 0231, 0123, 3120, 2130, 2013).
Language: We encoded the meta-tasks in language by sequences as follows:
• Classifying polynomials as constant/non-constant: [‘‘is’’, ‘‘constant’’] • Classifying polynomials as zero/non-zero intercept: [‘‘is’’, ‘‘intercept_nonzero’’] • For each variable, identifying whether that variable was relevant to the polynomial: [‘‘is’’, <variable-name>, ‘‘relevant’’] • Squaring polynomials: [
‘‘square’’] • Adding a constant: [‘‘add’’, <value>] • Multiplying by a constant: [‘‘multiply’’, <value>] • Permuting inputs: [‘‘permute’’, <variable-name>, <variable-name>, <variable-name>, <variable-name>]
All sequences were front-padded with “<PAD>” to the length of the longest sequence.
F.1. C ARD GAMES
Our card games were played with two suits, and 4 values per suit.
In our setup, each hand in a game has a win probability (proportional to how it ranks against all other possible hands).
The agent is dealt a hand, and then has to choose to bet 0, 1, or 2 (the three actions it has available).
We considered a variety of games which depend on different features of the hand:
• High card:
Highest card wins.
Pairs Same as high card, except pairs are more valuable, and same suit pairs are even more valuable.
• Straight ﬂush: Most valuable is adjacent numbers in same suit,
i
e. 4 and 3 in most valuable suit wins every time (royal ﬂush).
• Match: the hand with cards that differ least in value (suit counts as 0.5 pt difference) wins.
Blackjack:
The hand’s value increases with the sum of the cards until it crosses 5, at which point the player “goes bust,” and the value becomes negative.
We also considered three binary attributes that could be altered to produce variants of these games:
• Losers: Try to lose instead of winning!
Reverses the ranking of hands.
• Suits rule: Instead of suits being less important than values, they are more important (essentially ﬂipping the role of suit and value in most games).
• Switch suit: Switches which of the suits is more valuable.
Any combination of these options can be applied to any of the 5 games, yielding 40 possible games.
The systems were trained with the full 40 possible games, but after training we discovered that the “suits rule” option does not substantially alter the games we chose (in the sense that the probability of a hand winning in the two variants of a game is very highly correlated), so we have omitted it from our analyses.
Meta-tasks:
For meta-tasks, we gave the network 8 task-embedding classiﬁcation tasks (one-vs-all classiﬁcation of each of the 5 game types, and of each of the 3 attributes), and 3 meta-mapping tasks (each of the 3 attributes).
Language:
We encoded the meta-tasks in language by sequences of the form [‘‘toggle’’, <attribute-name>] for the meta-mapping tasks, and [‘‘is’’, <attribute-or-game-name>] .
F.
M ODEL & TRAINING
Basic task operation:
A training dataset D 1 of (input, target) pairs is embedded by I and T to produce a set of paired embeddings.
Another set of (possibly unlabeled) inputs D 2 is provided and embedded.
The meta network M maps the set of embedded (input, target) pairs to a function embedding.
The hyper network H maps the function embedding to parameters for F , which is used to transform the second set of inputs to a set of output embeddings.
The output embeddings are decoded by O to produce a set of outputs.
The system is trained end-to-end to minimize the loss on these outputs.
The model is trained to minimize
[Equation]
where F D 1 is the transformation the meta-learner guesses for the training dataset D 1 :
F D 1 is parameterized by H ( M ( { ( I ( x i ) , T ( y i )) for ( x i , y i )
∈ D 1 } ))
Meta-task operation:
A meta-dataset of (source-task-embedding, target-task-embedding) pairs, D 1 , is collected.
Another dataset D 2 (possibly only source tasks) is provided.
(All embeddings included in D 1 during training are for basic tasks that have themselves been trained, to ensure that there is useful signal.
During evaluation, the embeddings in D 1 are for tasks that have been trained on, but those in D 2 may be new.
The meta network M maps this set of (source, target) task-embedding pairs to a function embedding.
The hyper network H maps the function embedding to parameters for F , which is used to transform the second set of inputs to a set of output embeddings.
The system is trained to minimize (cid:96) 2 loss between these mapped embeddings and the target embeddings.
The model is trained to minimize
[Equation]
] where L is (cid:96) 2 loss, and F D 1 is the transformation the meta-learner guesses for the training dataset
D 1 :
F D 1 is parameterized by H ( M ( { (( z source , z target )
∈ D 1 } ))
Note that there are three kinds of hold-out in the training of this system, see Section A.1.
Language-cued meta-tasks: The procedure is analogous to the meta-tasks from examples, except that the input to H is the embedding of the language input, rather than the output of M .
The systems that were trained from language were also trained with the example-based meta-tasks.
F.2. D ETAILED HYPER - PARAMETERS
See table 1 for detailed architectural description and hyperparameters for each experiment.
Hyperparameters were generally found by a heuristic search, where mostly only the optimizer, learning rate annealing schedule, and number of training epochs were varied, not the architectural parameters.
Some of the parameters take the values they do for fairly arbitrary reasons, e.g. the continual learning experiments were run with the current polynomial hyperparameters before the hyperparameter search for the polynomial data was complete, so some parameters are altered between these.
Polynomials
Continual learning
Cards
Z -dimension
I num.
layers
I num.
hidden units
L architecture 2-layer LSTM +fully-connected1-layer LSTM +fully-connected
L num.
hidden unitsO num.
layers
O num.
hidden units - -
T num.
layers
M architecture 2 layers per-datum, max pool across, 2 layers
H architecture 4 layers
M , H num.
hidden units
F architecture 4 layers
F num.
hidden units
Nonlinearities
Leaky ReLU in most places, except no non-linearity at ﬁnal layer of T , M , L , F , and sigmoid for meta-classiﬁcation outputs.
Main loss (cid:96) 2 for main task & meta-mapping, cross-entropy for metaclassiﬁcation.
Optimizer
Adam
RMSProp RMSProp
Learning rate (base) 3 · 10 −1 · 10 −1 · 10 −
Learning rate (meta) 1 · 10 −- 1 · 10 −
L.R. decay rate (base) ∗ 0 .∗ 0 .∗ 0 .
L.R. decay rate (meta) ∗ 0 .- ∗ 0 .
L.R. min (base) 3 · 10 −
L.R. min (meta) 1 · 10 −- 3 · 10 −
L.R. decays every 100 epochs if above min.
Cached embedding L.R.
- 1 · 10 −-
Num.
training epochs
Num.
runs
Num. base tasks (eval)  36 or
Num. base tasks (training) 1200 (= 60 * 20) 36 or
Num.
meta classiﬁcationsNum
[Table]
Each epoch consisted of a separate learning step on each task (both base and meta), in a random order.
In each task, the meta-learner would receive only a subset (the “batch size“ above) of the examples to generate a function embedding, and would have to generalize to the remainder of the examples in the dataset.
The embeddings of the tasks for the meta-learner were computed once per epoch, so as the network learned over the course of the epoch, these embeddings would get “stale,” but this did not seem to be too detrimental.
The results reported in the ﬁgures in this paper are averages across multiple runs, with different trained and held-out tasks (in the polynomial case) and different network initializations (in all cases), to ensure the robustness of the ﬁndings.
F. S OURCE REPOSITORIES
(Will be included in de-anonymized version.)
G N UMERICAL RESULTS
In this section we provide the mean values and bootstrap conﬁdence intervals corresponding to the major ﬁgures in the paper, as well as the baseline results in those ﬁgures.
Tables were generated with stargazer (Hlavac, 2018) [Table]
G. P OLYNOMIALS
[Table]
[Table] [Table]
G. C ARDS
[Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]