# Automating Continual Learning

Kazuki Irie122footnotemark: 2 Róbert Csordás2 Jürgen Schmidhuber2,3
1Center for Brain Science, Harvard University, Cambridge, MA, USA
2The Swiss AI Lab, IDSIA, USI & SUPSI, Lugano, Switzerland
3AI Initiative, KAUST, Thuwal, Saudi Arabia
<EMAIL_ADDRESS>{robert<EMAIL_ADDRESS>
###### Abstract

General-purpose learning systems should improve themselves in open-ended
fashion in ever-changing environments. Conventional learning algorithms for
neural networks, however, suffer from catastrophic forgetting (CF)—previously
acquired skills are forgotten when a new task is learned. Instead of hand-
crafting new algorithms for avoiding CF, we propose Automated Continual
Learning (ACL) to train self-referential neural networks to meta-learn their
own in-context continual (meta-)learning algorithms. ACL encodes all
desiderata—good performance on both old and new tasks—into its meta-learning
objectives. Our experiments demonstrate that ACL effectively solves “in-
context catastrophic forgetting”; our ACL-learned algorithms outperform hand-
crafted ones, e.g., on the Split-MNIST benchmark in the replay-free setting,
and enables continual learning of diverse tasks consisting of multiple few-
shot and standard image classification datasets.111Our code is public:
https://github.com/IDSIA/automated-cl. †Work done at IDSIA.

##  1 Introduction

Enemies of memories are other memories (Eagleman, 2020). Continually-learning
artificial neural networks (NNs) are memory systems in which their weights
store memories of task-solving skills or programs, and their learning
algorithm is responsible for memory read/write operations. Conventional
learning algorithms—used to train NNs in the standard scenarios where all
training data is available at once—are known to be inadequate for continual
learning (CL) of multiple tasks where data for each task is available
sequentially and exclusively, one at a time. They suffer from “catastrophic
forgetting” (CF; McCloskey & Cohen (1989); Ratcliff (1990); French (1999);
McClelland et al. (1995)); the NNs forget, or rather, the learning algorithm
erases, previously acquired skills, in exchange of learning to solve a new
task. Naturally, a certain degree of forgetting is unavoidable when the memory
capacity is limited, and the amount of things to remember exceeds such an
upper bound. In general, however, capacity is not the fundamental cause of CF;
typically, the same NNs, suffering from CF when trained on two tasks
sequentially, can perform well on both tasks when they are jointly trained on
the two tasks at once instead (see, e.g., Irie et al. (2022a)). The real root
of CF lies in the learning algorithm as a memory mechanism. A “good” CL
algorithm should preserve previously acquired knowledge while also leveraging
previous learning experiences to improve future learning, by maximally
exploiting the limited memory space of model parameters. All of this is the
decision-making problem of learning algorithms. In fact, we can not blame the
conventional learning algorithms for causing CF, since they are not aware of
such a problem. They are designed to train NNs for a given task at hand; they
treat each learning experience independently (they are stationary up to
certain momentum parameters in certain optimizers), and ignore any potential
influence of current learning on past or future learning experiences.
Effectively, more sophisticated algorithms previously proposed against CF
(Kortge, 1990; French, 1991), such as elastic weight consolidation
(Kirkpatrick et al., 2017; Schwarz et al., 2018) or synaptic intelligence
(Zenke et al., 2017), often introduce manually-designed constraints as
regularization terms to explicitly penalize current learning for deteriorating
knowledge acquired in past learning.

Here, instead of hand-crafting learning algorithms for continual learning, we
train self-referential neural networks (Schmidhuber, 1992a; 1987) to meta-
learn their own “in-context” continual learning algorithms. We train them
through gradient descent on learning objectives that reflect desiderata for
continual learning algorithms—good performance on both old and new tasks,
including forward and backward transfer. In fact, by extending the standard
settings of few-shot or meta-learning based on sequence-processing NNs
(Hochreiter et al., 2001; Younger et al., 1999; Cotter & Conwell, 1991; 1990;
Mishra et al., 2018), the continual learning problem can also be formulated as
a long-span sequence processing task (Irie et al., 2022c). Corresponding
sequences can be obtained by concatenating multiple few-shot/meta-learning
sub-sequences, where each sub-sequence consists of input/target examples
corresponding to the task to be learned in-context. As we’ll see in Sec. 3,
this setting also allows us to seamlessly express classic desiderata for
continual learning (knowledge preservation, forward/backward transfer, etc.)
as part of objective functions of the meta-learner.

Once formulated as such a sequence-learning task, we let gradient descent
search for CL algorithms achieving the desired CL behaviors in the program
space of NN weights. In principle, all typical challenges of CL—such as the
stability-plasticity dilemma (Grossberg, 1982)—are automatically discovered
and handled by the gradient-based program search process. Once trained, CL is
automated through recursive self-modification dynamics of the trained NN,
without requiring any human intervention such as adding extra regularization
or setting hyper-parameters for continual learning. Therefore, we call our
method, Automated Continual Learning (ACL).

ACL requires training settings and datasets similar to those of few-shot/meta
learning problems: training sequences are constructed by shuffling target
labels for various combinations of underlying class categories, such that each
such sequence represents a new learning experience for the model. Our
experiments focus on supervised image classication, and make use of the
standard few-shot image classification datasets for meta-training, namely,
Mini-ImageNet (Vinyals et al., 2016; Ravi & Larochelle, 2017), Omniglot (Lake
et al., 2015), and FC100 (Oreshkin et al., 2018), while we also meta-test on
standard image classification datasets including MNIST families (LeCun et al.,
1998; Xiao et al., 2017) and CIFAR-10 (Krizhevsky, 2009). While these datasets
remain in the realm of toy tasks, they still allow us to clearly demonstrate
the effectiveness and promise of our ACL principle.

##  2 Background

Here we briefly review some background concepts that are essential for
describing our method in Sec. 3: continual learning and its desiderata (Sec.
2.1), few-shot/meta-learning via sequence processing (Sec. 2.2), and linear
Transformer/fast weight programmer architectures (Sec. 2.3) that are
foundations of the self-referential neural network we use in our experiments.

###  2.1 Continual Learning

Continual or lifelong learning is a special form of multi-task learning
(Thrun, 1998; Caruana, 1997). In conventional multi-task learning scenarios,
all datasets for different tasks are available at once, and NNs are trained
jointly on all of them (e.g., training batches mix examples from different
datasets without any particular order). In contrast, in continual learning
settings, presentation of tasks/datasets is sequential; an NN training process
only has access to one task/dataset at a time. When a dataset for a new task
becomes available, we lose access to the training examples from the previous
task, and so on.

The main focus of this work is on continual learning in supervised learning
settings even though high-level principles we discuss here also transfer to
reinforcement learning settings (Ring, 1994). In addition, we focus on the
realm of CL methods that keep model sizes constant (unlike certain CL methods
that incrementally add more parameters as more tasks are presented; see, e.g.,
Rusu et al. (2016)), and do not make use of any external replay memory (used
in other CL methods; see, e.g., Robins (1995); Shin et al. (2017); Rolnick et
al. (2019); Riemer et al. (2019); Zhang et al. (2022)).

Classic desiderata for a CL system (see, e.g., Lopez-Paz & Ranzato (2017);
Veniat et al. (2021)) are typically summarized as good performance on three
metrics: classification accuracies on each dataset (or their average),
backward transfer (i.e., impact of learning a new task on the model’s
performance on previous tasks; e.g., catastrophic forgetting is a negative
backward transfer), and forward transfer (impact of learning a task for the
model’s performance on a future task). From a broader perspective of meta-
learning systems, we may also measure other effects such as learning
acceleration (i.e., whether the system leverages previous learning experiences
to accelerate future learning); here we only briefly discuss this as our
primary focus remains the classic CL metrics above.

###  2.2 Few-shot/meta-learning via Sequence Learning

In Sec. 3, we’ll formulate continual learning as a long-span sequence
processing task. This is a direct extension of the classic few-shot/meta
learning formulated as a sequence learning problem. In fact, since the seminal
works by Hochreiter et al. (2001); Younger et al. (1999); Cotter & Conwell
(1991; 1990) (see also Naik & Mammone (1992)), many sequence processing neural
networks (see, e.g., Bosc (2015); Santoro et al. (2016); Duan et al. (2016);
Wang et al. (2017); Munkhdalai & Yu (2017); Munkhdalai & Trischler (2018);
Miconi et al. (2018; 2019); Munkhdalai et al. (2019); Kirsch & Schmidhuber
(2021); Sandler et al. (2021); Huisman et al. (2023) including “quadratic”
Transformers (Vaswani et al., 2017) as in Mishra et al. (2018)) have been
trained as a meta-learner (Schmidhuber, 1987; 1992a) that learn by observing
sequences of training examples (i.e., pairs of inputs and their labels) in-
context. Here we briefly review such a formulation.

Let $d$, $N$, $K$, $P$ be positive integers. In sequential $N$-way $K$-shot
classification settings, a sequence processing NN with a parameter vector
$\theta\in\mathbb{R}^{P}$ observes a pair (${\bm{x}}_{t}$, $y_{t}$) where
${\bm{x}}_{t}\in\mathbb{R}^{d}$ is the input and $y_{t}\in\\{1,...,N\\}$ is
its label at each step $t\in\\{1,...,N\cdot K\\}$, corresponding to $K$
examples for each one of $N$ classes. After the presentation of these $N\cdot
K$ examples (often called the support set), one extra input
${\bm{x}}\in\mathbb{R}^{d}$ (often called the query) is fed to the model
without its true label but an “unknown label” token $\varnothing$ (number of
input labels accepted by the model is thus $N+1$). The model is trained to
predict its true label, i.e., the parameters of the model $\theta$ are
optimized to maximize the probability
$p(y|({\bm{x}}_{1},y_{1}),...,({\bm{x}}_{N\cdot K},y_{N\cdot
K}),({\bm{x}},\varnothing);\theta)$ of the correct label $y\in\\{1,...,N\\}$
of the input query ${\bm{x}}$. Since class-to-label associations are
randomized and unique to each sequence
($({\bm{x}}_{1},y_{1}),...,({\bm{x}}_{N\cdot K},y_{N\cdot
K}),({\bm{x}},\varnothing)$), each such a sequence represents a new (few-shot
or meta) learning experience to train the model. To be more specific, this is
the synchronous label setting of Mishra et al. (2018) where the learning phase
(observing examples $({\bm{x}}_{1},y_{1}),...,({\bm{x}}_{N\cdot K},y_{N\cdot
K})$) is separated from the prediction phase (predicting label $y$ given
$({\bm{x}},\varnothing)$). We opt for this variant in our experiments as we
empirically find this (at least in our specific settings) more stable than the
delayed label setting (Hochreiter et al., 2001) where the model has to make a
prediction for every input, and the label is fed to the model with a delay of
one time step.

###  2.3 Self-Referential Weight Matrices or Recursive Linear Transformers

Our method (Sec. 3) can be applied to any sequence-processing NN architectures
in principle. Nevertheless, certain architectures naturally fit better to
parameterize a self-improving continual learner. Here we use the modern self-
referential weight matrix (SRWM; Irie et al. (2022c; 2023)) to build a generic
self-modifying NN. An SRWM is a weight matrix that sequentially modifies
itself as a response to a stream of input observations (Schmidhuber, 1992a;
1993). The modern SRWM belongs to the family of linear Transformers (LTs)
a.k.a. Fast Weight Programmers (FWPs; Schmidhuber (1991; 1992b); Katharopoulos
et al. (2020); Choromanski et al. (2021); Peng et al. (2021); Schlag et al.
(2021); Irie et al. (2021a)). Linear Transformers and FWPs are an important
class of the now popular Transformers (Vaswani et al., 2017): unlike the
standard ones whose computational requirements grow quadratically and whose
state size grows linearly with the context length, LTs/FWPs’ complexity is
linear and the state size is constant w.r.t. sequence length (like in the
standard RNNs). This is an important property for in-context CL, since,
conceptually, we want such a CL system to continue to learn for an arbitrarily
long, lifelong time span. Moreover, the duality between linear attention and
FWPs (Schlag et al., 2021)—and likewise, between linear attention and gradient
descent-trained linear layers (Irie et al., 2022a; Aizerman et al., 1964)—have
played a key role in certain theoretical analyses of in-context learning
capabilities of Transformers (von Oswald et al., 2023a; Dai et al., 2023).

The dynamics of an SRWM (Irie et al., 2022c) are described as follows. Let
$d_{\text{in}}$, $d_{\text{out}}$, $t$ be positive integers, and $\otimes$
denote outer product. At each time step $t$, an SRWM
${\bm{W}}_{t-1}\in\mathbb{R}^{(d_{\text{out}}+2*d_{\text{in}}+1)\times
d_{\text{in}}}$ observes an input ${\bm{x}}_{t}\in\mathbb{R}^{d_{\text{in}}}$,
and outputs ${\bm{y}}_{t}\in\mathbb{R}^{d_{\text{out}}}$, while also updating
itself to ${\bm{W}}_{t}$:

$\displaystyle[{\bm{y}}_{t},{\bm{k}}_{t},{\bm{q}}_{t},\beta_{t}]$
$\displaystyle={\bm{W}}_{t-1}{\bm{x}}_{t}$ (1)
$\displaystyle{\bm{v}}_{t}={\bm{W}}_{t-1}\phi({\bm{q}}_{t})$
$\displaystyle;\,\bar{{\bm{v}}}_{t}={\bm{W}}_{t-1}\phi({\bm{k}}_{t})$ (2)
$\displaystyle{\bm{W}}_{t}={\bm{W}}_{t-1}+\sigma($
$\displaystyle\beta_{t})({\bm{v}}_{t}-\bar{{\bm{v}}}_{t})\otimes\phi({\bm{k}}_{t})$
(3)

where
${\bm{v}}_{t},\bar{{\bm{v}}}_{t}\in\mathbb{R}^{(d_{\text{out}}+2*d_{\text{in}}+1)}$
are value vectors, ${\bm{q}}_{t}\in\mathbb{R}^{d_{\text{in}}}$ and
${\bm{k}}_{t}\in\mathbb{R}^{d_{\text{in}}}$ are query and key vectors, and
$\sigma(\beta_{t})\in\mathbb{R}$ is the learning rate. $\sigma$ and $\phi$
denote sigmoid and softmax functions respectively. $\phi$ is typically also
applied to ${\bm{x}}_{t}$ in Eq. 1; here we follow Irie et al. (2022c)’s few-
shot image classification setting, and use the variant without it. Eq. 3
corresponds to a rank-one update of the SRWM, from ${\bm{W}}_{t-1}$ to
${\bm{W}}_{t}$, through the delta learning rule (Widrow & Hoff, 1960; Schlag
et al., 2021) where the self-generated patterns, ${\bm{v}}_{t}$,
$\phi({\bm{k}}_{t})$, and $\sigma(\beta_{t})$, play the role of target, input,
and learning rate of the learning rule respectively. The delta rule in FWPs is
typically reported to be crucial broadly across many practical tasks (Schlag
et al., 2021; Irie et al., 2021a; 2022b; Irie & Schmidhuber, 2023b).

The initial weight matrix ${\bm{W}}_{0}$ is the only trainable parameters of
this layer, that encodes the initial self-modification algorithm. In practice,
we use the layer above as a direct replacement to the self-attention layer in
the Transformer architecture (Vaswani et al., 2017); we also use the multi-
head version of the SRWM computation above. For further details, we refer to
Irie et al. (2022c).

Figure 1: An illustration of meta-training in Automated Continual Learning
(ACL) for a self-referential/modifying weight matrix ${\bm{W}}_{0}$. Weights
${\bm{W}}_{\mathcal{A}}$ obtained by observing examples for Task A (blue) are
used to predict a test example for Task A. Weights
${\bm{W}}_{\mathcal{A},\mathcal{B}}$ obtained by observing examples for Task A
then those for Task B (yellow) are used to predict a test example for Task A
(backward transfer) as well as a test example for Task B (forward transfer).

##  3 Method

Task Formulation. We formulate continual learning as a long-span sequence
learning task. Let $D$, $N$, $K$, $L$ denote positive integers. Consider two
$N$-way classification tasks ${\mathbf{A}}$ and ${\mathbf{B}}$ to be learned
sequentially (as we’ll see, this can also be straightforwardly extended to
three or more tasks; also the formulation here applies to both “meta-training”
and “meta-test” phases, see Appendix A.1 for more on the terminology). We
denote the respective training datasets as $\mathcal{A}$ and $\mathcal{B}$,
and test sets as $\mathcal{A^{\prime}}$ and $\mathcal{B^{\prime}}$. We assume
that each datapoint in these datasets consists of one input feature
${\bm{x}}\in\mathbb{R}^{D}$ of dimension $D$ (generically denoted as vector
${\bm{x}}$, but it is an image in all our experiments) and one label
$y\in\\{1,...,N\\}$ denoting one out of $N$ classes. We consider two sequences
of $L$ training examples
$\left(({\bm{x}}^{\mathcal{A}}_{1},y^{\mathcal{A}}_{1}),...,({\bm{x}}^{\mathcal{A}}_{L},y^{\mathcal{A}}_{L})\right)$
and
$\left(({\bm{x}}^{\mathcal{B}}_{1},y^{\mathcal{B}}_{1}),...,({\bm{x}}^{\mathcal{B}}_{L},y^{\mathcal{B}}_{L})\right)$
sampled from the respective training sets $\mathcal{A}$ and $\mathcal{B}$. In
practice, $L=NK$ where $K$ is the number of training examples for each class.
By concatenating these two sequences, we obtain one long sequence representing
continual learning examples to be presented as an input sequence to a (left-
to-right) auto-regressive model. At the end of the sequence, the model is
tasked to make predictions on test examples sampled from both
$\mathcal{A^{\prime}}$ and $\mathcal{B^{\prime}}$; we assume a single test
example for each task (hence, without index):
$({\bm{x}}^{\mathcal{A^{\prime}}},y^{\mathcal{A^{\prime}}})$ and
$({\bm{x}}^{\mathcal{B^{\prime}}},y^{\mathcal{B^{\prime}}})$ respectively; let
us further simplify the notation and denote them as
$({\bm{x}}^{\mathcal{A}}_{\text{test}},y^{\mathcal{A}}_{\text{test}})$ and
$({\bm{x}}^{\mathcal{B}}_{\text{test}},y^{\mathcal{B}}_{\text{test}})$
instead.

Our model is a self-referential neural network that modifies its own weight
matrices as a function of input observations. To simplify the notation, we
denote the state of our self-referential NN as a single SRWM ${\bm{W}}_{*}$
(even though, in practice, it may have many of them) where we’ll replace $*$
by various symbols representing the context/inputs it has observed. Given a
training sequence
$\left(({\bm{x}}^{\mathcal{A}}_{1},y^{\mathcal{A}}_{1}),...,({\bm{x}}^{\mathcal{A}}_{L},y^{\mathcal{A}}_{L}),({\bm{x}}^{\mathcal{B}}_{1},y^{\mathcal{B}}_{1}),...,({\bm{x}}^{\mathcal{B}}_{L},y^{\mathcal{B}}_{L})\right)$,
our model consumes one input at a time, from left to right, in the auto-
regressive fashion. Let ${\bm{W}}_{\mathcal{A}}$ denote the state of the SRWM
that has consumed the first part of the sequence corresponding to the examples
from Task ${\mathbf{A}}$, i.e.,
$({\bm{x}}^{\mathcal{A}}_{1},y^{\mathcal{A}}_{1}),...,({\bm{x}}^{\mathcal{A}}_{L},y^{\mathcal{A}}_{L})$,
and let ${\bm{W}}_{\mathcal{A},\mathcal{B}}$ denote the state of our SRWM
having observed the entire sequence.

ACL Meta-Training Objectives. The ACL objective function consists in tasking
the model to correctly predict the test examples of all tasks learned so far
at each task boundaries. That is, in the case of two-task scenario described
above (learning Task ${\mathbf{A}}$ then Task ${\mathbf{B}}$), we use the
weight matrix ${\bm{W}}_{\mathcal{A}}$ to predict the label
$y^{\mathcal{A}}_{\text{test}}$ from input
$({\bm{x}}^{\mathcal{A}}_{\text{test}},\varnothing)$, and we use the weight
matrix ${\bm{W}}_{\mathcal{A},\mathcal{B}}$ to predict the label
$y^{\mathcal{B}}_{\text{test}}$ from input
$({\bm{x}}^{\mathcal{B}}_{\text{test}},\varnothing)$ as well as the label
$y^{\mathcal{A}}_{\text{test}}$ from input
$({\bm{x}}^{\mathcal{A}}_{\text{test}},\varnothing)$. By letting
$p(y|{\bm{x}};{\bm{W}}_{*})$ denote the model’s output probability for label
$y\in\\{1,..,N\\}$ given input ${\bm{x}}$ and model weights/state
${\bm{W}}_{*}$, the ACL objective function can be expressed as:

$\displaystyle\mathop{\text{missing}}{minimize}_{\theta}-\left(\log(p(y^{\mathcal{A}}_{\text{test}}|{\bm{x}}^{\mathcal{A}}_{\text{test}};{\bm{W}}_{\mathcal{A}}))+\log(p(y^{\mathcal{B}}_{\text{test}}|{\bm{x}}^{\mathcal{B}}_{\text{test}};{\bm{W}}_{\mathcal{A,B}}))+\log(p(y^{\mathcal{A}}_{\text{test}}|{\bm{x}}^{\mathcal{A}}_{\text{test}};{\bm{W}}_{\mathcal{A,B}}))\right)$
(4)

for an input meta-training sequence
$\left(({\bm{x}}^{\mathcal{A}}_{1},y^{\mathcal{A}}_{1}),...,({\bm{x}}^{\mathcal{A}}_{L},y^{\mathcal{A}}_{L}),({\bm{x}}^{\mathcal{B}}_{1},y^{\mathcal{B}}_{1}),...,({\bm{x}}^{\mathcal{B}}_{L},y^{\mathcal{B}}_{L})\right)$
(extensible to mini-batches with multiple such sequences), where $\theta$
denotes the model parameters (for the SRWM layer, it is the initial weights
${\bm{W}}_{0}$). Figure 1 illustrates the overall meta-training process of
ACL.

The ACL objective function above (Eq. 4) is simple but encapsulates desiderata
for continual learning (reviewed in Sec. 2.1). The last term of Eq. 4 with
$p(y^{\mathcal{A}}_{\text{test}}|{\bm{x}}^{\mathcal{A}}_{\text{test}};{\bm{W}}_{\mathcal{A,B}})$
or schematically ${\bm{p}}(\mathcal{A}^{\prime}|\mathcal{A},\mathcal{B})$,
optimizes for backward transfer: (1) remembering the first task ${\mathbf{A}}$
after learning ${\mathbf{B}}$ (combatting catastrophic forgetting), and (2)
leveraging learning of ${\mathbf{B}}$ to improve performance on the past task
${\mathbf{A}}$. The second term of Eq. 4,
$p(y^{\mathcal{B}}_{\text{test}}|{\bm{x}}^{\mathcal{B}}_{\text{test}};{\bm{W}}_{\mathcal{A,B}})$
or schematically ${\bm{p}}(\mathcal{B}^{\prime}|\mathcal{A},\mathcal{B})$,
optimizes forward transfer leveraging the past learning experience of
${\mathbf{A}}$ to improve predictions in the second task ${\mathbf{B}}$, in
addition to simply learning to solve Task ${\mathbf{B}}$ from the
corresponding training examples. To complete, the first term of Eq. 4 is a
simple single-task meta-learning objective for Task ${\mathbf{A}}$.

Overall Model Architecture. As we mention in Sec. 2, in our NN architecture,
the core sequential dynamics of continual learning are learned by the self-
referential layers. However, as an image-processing NN, our model makes use of
a vision backend consisting of multiple convolutional layers. In practice, we
use the “Conv-4” architecture of Vinyals et al. (2016) typically used in the
context of few-shot learning. Overall, the model takes an image as input,
process it through a feedforward convolutional NN, whose output is fed to the
SRWM-layer block. Note that this is one of the limitations of this work. While
our architecture with fixed vision components still allows us to
experimentally demonstrate the principle of ACL, more general ACL should make
use of self-modifying NNs that also learn to modify the vision components. One
straightforward architecture fitting the bill is an MLP-mixer architecture
(Tolstikhin et al. (2021); built of several linear layers), where all linear
layers are replaced by the self-referential linear layers of Sec. 2.3. While
we implemented such a model, it turned out to be too slow for us to conduct
corresponding experiments. Our public code includes a self-referential MLP-
mixer implementation, but for further experiments, we leave the future work
with such an architecture using more efficient CUDA kernels.

Another crucial architectural choice that is specific to continual/multi-task
image processing is normalization layers (see also Bronskill et al. (2020)).
Typical NNs used in few-shot learning (e.g., Vinyals et al. (2016)) contain
batch normalization (BN; Ioffe & Szegedy (2015)) layers. All our models use
instance normalization (IN; Ulyanov et al. (2016)) instead of BN because in
our preliminary experiments, as expected, we found IN to generalize much
better than BN layers in the CL setting.

##  4 Experiments

Base Settings. Unless otherwise indicated (e.g, for classic Split-MNIST; Sec.
4.3), all tasks are configured to be a 5-way classification task. This is one
of the classic configurations for few-shot learning tasks, and also allows us
to evaluate the principle of ACL with reasonable computational costs (like any
sequence learning-based meta-learning methods, scaling this to many more
classes is challenging; we also discuss this in Sec. 5). For standard datasets
such as MNIST, we split the dataset into sub-datasets of disjoint classes
(Srivastava et al., 2013): for example for MNIST which is originally a 10-way
classification task, we split it into two 5-way tasks, one consisting of
images of class ‘0’ to ‘4’ (‘MNIST-04’), and another one made of class ‘5’ to
‘9’ images (‘MNIST-59’). When we refer to a dataset without specifying the
class range, we refer to the first sub-set. Unless stated otherwise, we
concatenate 15 examples for each class for each task in the context for both
meta-training and meta-testing (resulting in sequences of length 75 for each
task). All images are resized to $32\times 32$-size $3$-channel images, and
normalized according to the original dataset statistics. Appendix A provides
further details.

Table 1: 5-way classification accuracies using 15 (meta-test training)
examples for each class in the context. Each row corresponds to a single
model. Bold numbers highlight cases where in-context catastrophic forgetting
is avoided through ACL.

|  |  | Meta-Test Tasks: Context/Train (top) & Test (bottom)
---|---|---|---
Meta-Training Tasks |  | A | A $\rightarrow$ B | B | B $\rightarrow$ A
Task A | Task B | ACL | A | B | A | B | A | B
Omniglot | Mini-ImageNet | No | 97.6 $\pm$ 0.2 | 52.8 $\pm$ 0.7 | 22.9 $\pm$ 0.7 | 52.1 $\pm$ 0.8 | 97.8 $\pm$ 0.3 | 20.4 $\pm$ 0.6
|  | Yes | 98.3 $\pm$ 0.2 | 54.4 $\pm$ 0.8 |  98.2 $\pm$ 0.2 | 54.8 $\pm$ 0.9 | 98.0 $\pm$ 0.3 |  54.6 $\pm$ 1.0
FC100 | Mini-ImageNet | No | 49.7 $\pm$ 0.7 | 55.0 $\pm$ 1.0 | 21.3 $\pm$ 0.7 | 55.1 $\pm$ 0.6 | 49.9 $\pm$ 0.8 | 21.7 $\pm$ 0.8
|  | Yes | 53.8 $\pm$ 1.7 | 52.5 $\pm$ 1.2 |  46.2 $\pm$ 1.3 | 59.9 $\pm$ 0.7 | 45.5 $\pm$ 0.9 |  53.0 $\pm$ 0.6

Table 2: Similar to Table 2 above but using MNIST and CIFAR-10 (unseen
domains) for meta-testing.

|  |  | Meta-Test Tasks: Context/Train (top) & Test (bottom)
---|---|---|---
Meta-Training Tasks |  | MNIST | MNIST $\rightarrow$ CIFAR-10 | CIFAR-10 | CIFAR-10 $\rightarrow$ MNIST
Task A | Task B | ACL | MNIST | CIFAR-10 | MNIST | CIFAR-10 | MNIST | CIFAR-10
Omniglot | Mini-ImageNet | No | 71.1 $\pm$ 4.0 | 49.4 $\pm$ 2.4 | 43.7 $\pm$ 2.3 | 51.5 $\pm$ 1.4 | 68.9 $\pm$ 4.1 | 24.9 $\pm$ 3.2
|  | Yes | 75.4 $\pm$ 3.0 | 50.8 $\pm$ 1.3 |  81.5 $\pm$ 2.7 | 51.6 $\pm$ 1.3 | 77.9 $\pm$ 2.3 |  51.8 $\pm$ 2.0
FC100 | Mini-ImageNet | No | 60.1 $\pm$ 2.0 | 56.1 $\pm$ 2.3 | 17.2 $\pm$ 3.5 | 54.4 $\pm$ 1.7 | 58.6 $\pm$ 1.6 | 21.2 $\pm$ 3.1
|  | Yes | 70.0 $\pm$ 2.4 | 51.0 $\pm$ 1.0 |  68.2 $\pm$ 2.7 | 59.2 $\pm$ 1.7 | 66.9 $\pm$ 3.4 |  52.5 $\pm$ 1.3

###  4.1 Two-Task Evaluation

We first demonstrate the essence of our method (Sec. 3) in the two-task
“domain-incremental” CL setting (see Appendix A.1). We consider two meta-
training task combinations: Omniglot (Lake et al., 2015) and Mini-ImageNet
(Vinyals et al., 2016; Ravi & Larochelle, 2017) or FC100 (Oreshkin et al.,
2018) (which is based on CIFAR100 (Krizhevsky, 2009)) and Mini-ImageNet. The
order of appearance of two tasks within meta-training sequences is alternated
for every batch. We compare systems trained with or without the backward
transfer term in the ACL loss (the last term in Eq. 4).

Table 2 shows the results when the models are meta-tested on the test sets of
the corresponding few-shot learning datasets used for meta-training. We
observe that in both pairs of training tasks, the models without the ACL loss
catastrophically forget the first task after learning the second one: the
accuracy on the first task is at the chance level of about 20% for 5-way
classification after learning the second task in-context. The ACL loss clearly
addresses this problem: the ACL-learned CL algorithms preserve the performance
of the first task. This effect is particularly pronounced in the
Omniglot/Mini-ImageNet case (involving two very different domains).

Table 2 shows a similar evaluation but on two standard datasets, 5-way MNIST
and CIFAR-10. Again, ACL-trained models better preserve the memory of the
first task after learning the second one. In the Omniglot/Mini-ImageNet case,
we even observe certain positive backward tranfer effects: in particular, in
the “MNIST-then-CIFAR10” continual learning case, the performance on MNIST
noticeably improves after learning CIFAR10 (possibly leveraging ‘more data’
provided in-context).

###  4.2 In-Context Catastrophic Forgetting in the Baselines

Here we report some empirical observations on the baseline models trained
without the backward transfer term (the last/third term in Eq. 4) in the ACL
objective loss (corresponding to the ACL/No cases in Tables 2 and 2), namely
emergence of “in-context catastrophic forgetting” during training. We focus on
the Omniglot/Mini-ImageNet case, but similar trends can also be observed in
the FC100/Mini-ImageNet case. Figures 2a and 2b show two cases we typically
observe. These figures show an evolution of six individual meta-training loss
terms (the lower the better), reported separately for the cases where Task A
(here Omniglot) or Task B (here Mini-ImageNet) appears at the first (1) or
second (2) position in the 2-task continual learning training sequences. 4 out
of 6 curves correspond to the learning progress, showing whether the model
becomes capable of in-context learning the given task (A or B) at the given
position (1 or 2). The 2 remaining curves are the ACL backward tranfer loss,
also measured for Task A and B separately here.

Figure 2a shows the case where two tasks are learned about at the same time.
We observe that when the learning curves go down, the ACL losses go up,
indicating that more the model learns, more it tends to forget the task in-
context learned previously. This trend is similar when one task is learned
before the other one as is the case in Figure 2b. Here Task A alone is learned
first; while Task B is not learned, both learning and ACL curves go down for
Task A (essentially, as the model does not learn the second task, there is no
force that encourages forgetting). At around 3000 steps, the model also starts
learning Task B. From this point, the ACL loss for Task A also starts to go
up, indicating again an opposing force effect between learning a new task and
remembering a past task. These observations clearly indicate that, without
explicitly taking into account the backward transfer loss as part of learning
objectives, the gradient descent search tends to find solutions/CL algorithms
that prefer to erase previously learned knowledge (this is rather intuitive;
it seems easier to find such algorithms that ignore any influence of the
current learning to past learning than those that also preserve prior
knowledge). In all cases, we find our ACL objective to be crucial for the
learned CL algorithms to be capable of remembering the old task while also
learning the new task at the same.

(a) Case: Two tasks are learned simultaneously.

(b) Case: One task is learned first (here Task A).

Figure 2: ACL/No-case meta-training curves displaying 6 individual meta-
training loss terms, when the last term of the ACL objective (the backward
tranfer loss; “Task A ACL bwd” and “Task B ACL bwd” in the legend) is not
minimized (ACL/No case in Tables 2 and 2). Here Task A is Omniglot and Task B
is Mini-ImageNet. We observe that, in both cases, without explicit
minimization, backward transfer capability (purple and brown curves) of the
learned learning algorithm gradually degrades as it learns to learn a new task
(all other colors), causing in-context catastrophic forgetting. Note that
blue/orange and green/red curve pairs almost overlap; indicating that when a
task is learned, the model can learn it whether it is in the first or second
segment of the continual learning sequence.

###  4.3 General Evaluation

Table 3: Classification accuracies (%) on the Split-MNIST domain-incremental (DIL) and class-incremental learning (CIL) settings (Hsu et al., 2018). Both tasks are 5-task CL problems. For the CIL case, we also report the 2-task case for which we can directly evaluate our out-of-the-box ACL meta-learner of Sec. 4.1 (trained with a 5-way output and the 2-task ACL loss) which, however, is not applicable (N.A.) to the 5-task CIL requiring a 10-way output. Mean/std over 10 training/meta-testing runs. None of the methods here requires replay memory. See Appendix A.7/B.1 for further details. | Domain Incremental | Class Incremental
---|---|---
Method | 5-task | 2-task | 5-task
Plain Stochastic Gradient Descent (SGD) | 63.2 $\pm$ 0.4 | 48.8 $\pm$ 0.1 | 19.5 $\pm$ 0.1
Adam | 55.2 $\pm$ 1.4 | 49.7 $\pm$ 0.1 | 19.7 $\pm$ 0.1
Adam + L2 | 66.0 $\pm$ 3.7 | 51.8 $\pm$ 1.9 | 22.5 $\pm$ 1.1
Elastic Weight Consolidation (EWC) | 58.9 $\pm$ 2.6 | 49.7 $\pm$ 0.1 | 19.8 $\pm$ 0.1
Online EWC | 57.3 $\pm$ 1.4 | 49.7 $\pm$ 0.1 | 19.8 $\pm$ 0.1
Synaptic Intelligence (SI) | 64.8 $\pm$ 3.1 | 49.4 $\pm$ 0.2 | 19.7 $\pm$ 0.1
Memory Aware Synapses (MAS) | 68.6 $\pm$ 6.9 | 49.6 $\pm$ 0.1 | 19.5 $\pm$ 0.3
Learning w/o Forgetting (LwF) | 71.0 $\pm$ 1.3 | - | 24.2 $\pm$ 0.3
Online-aware Meta Learning (OML; Out-of-the-box) | 69.9 $\pm$ 2.8 | 46.6 $\pm$ 7.2 | 24.9 $\pm$ 4.1
\+ optimized # meta-testing iterations | 73.6 $\pm$ 5.3 | 62.1 $\pm$ 7.9 | 34.2 $\pm$ 4.6
ACL (Out-of-the-box, DIL, 2-task ACL model; Sec. 4.1) | 72.2 $\pm$ 0.9 | 71.5 $\pm$ 5.9 | N.A.
\+ meta-finetuned with 5-task ACL loss, Omniglot |  84.3 $\pm$ 1.2 |  93.4 $\pm$ 1.2 |  74.6 $\pm$ 2.3

Evaluation on standard Split-MNIST. Here we evaluate ACL on the standard
Split-MNIST task in domain-incremental and class-incremental settings (Hsu et
al., 2018; Van de Ven & Tolias, 2018b), and compare its performance to
existing CL and meta-CL algorithms (see Appendix A.7 for full references of
these methods). Our comparison focuses on methods that do not require replay
memory. Table 3 shows the results. Since our ACL-trained models are general-
purpose learners, they can be directly evaluated (meta-tested) on a new task,
here Split-MNIST. “ACL (Out-of-the-box model)” row of Table 3 corresponds to
our model from Sec. 4.1 meta-trained on Omniglot and Mini-ImageNet using the
2-task ACL objective. It performs very competitively with the best existing
methods in the domain-incremental setting, while it largely outperforms them
in the 2-task class-incremental setting. The same model can be further meta-
finetuned using the 5-task version of the ACL loss (here we only used Omniglot
as the meta-training data). The resulting model (the last row of Table 3)
outperforms all other methods in all settings studied here. We refer to
Appendix A.7/B.1 for further discussions.

Evaluation on diverse task domains. Here we evaluate our ACL-trained models
for CL involving more tasks/domains; using meta-test sequences made of MNIST,
CIFAR-10, and Fashion MNIST (FMNIST). We also evaluate the impact of the
number of tasks in the ACL objective: in addition to the model meta-trained on
Omniglot/Mini-ImageNet (Sec. 4.1), we also meta-train a model (with the same
architecture and hyper-parameters) using 3 tasks, Omniglot, Mini-ImageNet, and
FC100, using the 3-task ACL objective (see Appendix A.5); which is not only
meta-trained for longer CL, but also uses more data. Table 4 shows the
results. The two ACL-trained models are indeed capable of retaining the
knowledge without catastrophic forgetting for multiple tasks during meta-
testing, while the performance on prior tasks gradually degrades as the model
learns new tasks, and performance on new tasks becomes moderate (see Sec. 5 on
limitations). The 3-task version outperforms the 2-task one overall,
encouragingly indicating a potential for further improvements even with a
fixed parameter count.

Table 4: 5-way classification accuracies using 15 examples for each class for each task in the context. 2-task models are meta-trained on Omniglot and Mini-ImageNet, while 3-task models are in addition meta-trained on FC100. ‘A, B’ in ‘Context/Train’ column indicates that models sequentially observe meta-test training examples of Task A then B; evaluation is only done at the end of the sequence. Meta-Testing Tasks | Number of Meta-Training Tasks
---|---
Context/Train | Test | 2 (no ACL) | 2 | 3
A: MNIST-04 | A | 71.1 $\pm$ 4.0 | 75.4 $\pm$ 3.0 | 89.7 $\pm$ 1.6
B: CIFAR10-04 | B | 51.5 $\pm$ 1.4 | 51.6 $\pm$ 1.3 | 55.3 $\pm$ 0.9
C: MNIST-59 | C | 65.9 $\pm$ 2.4 | 63.0 $\pm$ 3.3 | 76.1 $\pm$ 2.0
D: FMNIST-04 | D | 52.8 $\pm$ 3.4 | 54.8 $\pm$ 1.3 | 59.2 $\pm$ 4.0
| Average | 60.3 | 61.2 | 70.1
A, B | A | 43.7 $\pm$ 2.3 | 81.5 $\pm$ 2.7 | 88.0 $\pm$ 2.2
| B | 49.4 $\pm$ 2.4 | 50.8 $\pm$ 1.3 | 52.9 $\pm$ 1.2
| Average | 46.6 | 66.1 | 70.5
A, B, C | A | 26.5 $\pm$ 3.2 | 64.5 $\pm$ 6.0 | 82.2 $\pm$ 1.7
| B | 32.3 $\pm$ 1.7 | 50.8 $\pm$ 1.2 | 50.3 $\pm$ 2.0
| C | 56.5 $\pm$ 8.1 | 33.7 $\pm$ 2.2 | 44.3 $\pm$ 3.0
| Average | 38.4 | 49.7 | 58.9
A, B, C, D | A | 24.6 $\pm$ 2.7 | 64.3 $\pm$ 4.8 | 78.9 $\pm$ 2.3
| B | 20.6 $\pm$ 2.3 | 47.5 $\pm$ 1.0 | 49.2 $\pm$ 1.3
| C | 38.5 $\pm$ 4.4 | 32.7 $\pm$ 1.9 | 45.4 $\pm$ 3.9
| D | 36.1 $\pm$ 2.5 | 31.2 $\pm$ 4.9 | 30.1 $\pm$ 5.8
| Average | 30.0 | 43.9 | 50.9

##  5 Discussion

Prior work. While there are several recent works that are catagorized as
‘meta-continual learning’ or ‘continual meta-learning’ (see, e.g., Javed &
White (2019); Beaulieu et al. (2020); Caccia et al. (2020); He et al. (2019);
Yap et al. (2021); Munkhdalai & Yu (2017), most of them are based on “model-
agnostic meta-learning” (MAML; Finn et al. (2017); Finn & Levine (2018)) and
learn representations for CL but still make use of classic CL algorithms. In
particular, tuning of the learning rate and number of iterations is still
required for optimal performance (see, e.g., Appendix A.7). In contrast, our
approach learn learning algorithms in the spirit of Hochreiter et al. (2001);
Younger et al. (1999); this may be categorized as ‘in-context continual
learning.’ Several recent works (see, e.g., Irie & Schmidhuber (2023a); Coda-
Forno et al. (2023); von Oswald et al. (2023b)) mention the possibility of
such in-context CL without any concrete study. We show that in-context
learning also suffers from catastrophic forgetting (Sec. 4.1-4.2) and propose
ACL to address this problem. We also note that the use of SRWM is relevant to
‘continual meta-learning’ since with a regular sequence processor with slow
weights, there remains the question of how to continually learn the slow
weights (meta-parameters). In principle, recursive self-modification as in
SRWM is an answer to this question as it collapses such meta-levels into
single self-reference (Schmidhuber, 1992a). We also refer to Schmidhuber
(1994; 1995); Schmidhuber et al. (1997) for other prior work on meta-continual
learning.

Artificial v. Natural ACL in Large Language Models? Recently, “on-the-fly”
few-shot/meta learning capability of sequence processing NNs has attracted
broader interests in the context of large language models (LLMs; Radford et
al. (2019)). In fact, the task of language modeling itself has a form of
sequence processing with error feedback (essential for meta-learning
(Schmidhuber, 1990)): the correct label to be predicted is fed to the model
with a delay of one time step in an auto-regressive manner. Trained on a large
amount of text covering a wide variety of credit assignment paths, LLMs
exhibit certain sequential few-shot learning capabilities in practice (Brown
et al., 2020). This was rebranded as in-context learning, and has been the
subject of numerous recent studies (e.g., Xie et al. (2022); Min et al.
(2022); Yoo et al. (2022); Chan et al. (2022b; a); Kirsch et al. (2022);
Akyürek et al. (2023); von Oswald et al. (2023a); Dai et al. (2023)). Here we
explicitly/artificially construct ACL meta-training sequences and objectives,
but in modern LLMs trained on a large amount of data mixing a large diversity
of dependencies using a large backpropagation span, it is conceivable that
some ACL-like objectives may naturally appear in the data.

Limitations. While we argue that our ACL is a promising approach for
automating development of CL algorithms, there are also several limitations.
First of all, directly scaling ACL for real-world tasks requiring many more
classes does not seem straightforward: it would require very long training
sequences. That said, it is also possible that ACL could be achieved without
exactly following the process we propose; as we mention above for the case of
LLMs, certain real-world data may naturally give rise to an ACL-like
objective. Another limitation of this work is training within the limited
span. We noted that unlike the standard “quadratic” Transformers, linear
Transformers/FWPs-like SRWMs can be trained by carrying over states across two
consecutive batches for arbitrarily long sequences. Such an approach has been
successfully applied to language modeling with FWPs (Schlag et al., 2021).
This possibility, however, has not been investigated here, and is left for
future work. This work is also limited to the task of image classification,
which can be solved by feedforward NNs. Future work may investigate the
possibility to extend ACL to continual learning of sequence learning tasks,
such as continually learning new languages. Finally, ACL learns CL algorithms
that are specific to the pre-specified model architecture; more general meta-
learning algorithms may aim at achieving learning algorithms that are
applicable to any model, as is the case for many classic learning algorithms.

##  6 Conclusion

Our novel Automated Continual Learning (ACL) formulates continual learning as
sequence learning across long time lags, and trains sequence-processing self-
referential neural networks (SRNNs) to learn their own in-context continual
(meta-)learning algorithms. ACL encodes classic desiderata for continual
learning (such as knowledge preservation, forward and backward transfer, etc.)
into the objective function of the meta-learner. ACL uses gradient descent to
deal with classic challenges of CL, to automatically discover CL algorithms
with good behavior. Once trained, our SRNNs autonomously run their own
continual learning algorithms without requiring any human intervention. Our
experiments demonstrate the effectiveness and promise of the proposed
approach.

## Acknowledgements

This research was partially funded by ERC Advanced grant no: 742870, project
AlgoRNN, and by Swiss National Science Foundation grant no: 200021_192356,
project NEUSYM. We are thankful for hardware donations from NVIDIA and IBM.
The resources used for this work were partially provided by Swiss National
Supercomputing Centre (CSCS) projects s1145 and d123.

## References

  * Aizerman et al. (1964) Mark A. Aizerman, Emmanuil M. Braverman, and Lev I. Rozonoer.  Theoretical foundations of potential function method in pattern recognition.  _Automation and Remote Control_ , 25(6):917–936, 1964.
  * Akyürek et al. (2023) Ekin Akyürek, Dale Schuurmans, Jacob Andreas, Tengyu Ma, and Denny Zhou.  What learning algorithm is in-context learning? investigations with linear models.  In _Int. Conf. on Learning Representations (ICLR)_ , Kigali, Rwanda, May 2023.
  * Aljundi et al. (2018) Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars.  Memory aware synapses: Learning what (not) to forget.  In _Proc. European Conf. on Computer Vision (ECCV)_ , pp. 144–161, Munich, Germany, September 2018.
  * Banayeeanzade et al. (2021) Mohammadamin Banayeeanzade, Rasoul Mirzaiezadeh, Hosein Hasani, and Mahdieh Soleymani.  Generative vs. discriminative: Rethinking the meta-continual learning.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 21592–21604, Virtual only, December 2021.
  * Beaulieu et al. (2020) Shawn Beaulieu, Lapo Frati, Thomas Miconi, Joel Lehman, Kenneth O. Stanley, Jeff Clune, and Nick Cheney.  Learning to continually learn.  In _Proc. European Conf. on Artificial Intelligence (ECAI)_ , pp. 992–1001, August 2020.
  * Bosc (2015) Tom Bosc.  Learning to learn neural networks.  In _NIPS Workshop on Reasoning, Attention, Memory_ , Montreal, Canada, December 2015.
  * Bronskill et al. (2020) John Bronskill, Jonathan Gordon, James Requeima, Sebastian Nowozin, and Richard E. Turner.  TaskNorm: Rethinking batch normalization for meta-learning.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 1153–1164, Virtual only, 2020.
  * Brown et al. (2020) Tom B Brown et al.  Language models are few-shot learners.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , Virtual only, December 2020.
  * Caccia et al. (2020) Massimo Caccia, Pau Rodríguez, Oleksiy Ostapenko, Fabrice Normandin, Min Lin, Lucas Page-Caccia, Issam Hadj Laradji, Irina Rish, Alexandre Lacoste, David Vázquez, and Laurent Charlin.  Online fast adaptation and knowledge accumulation (OSAKA): a new approach to continual learning.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , Virtual only, December 2020.
  * Caruana (1997) Rich Caruana.  Multitask learning.  _Machine learning_ , 28:41–75, 1997.
  * Chan et al. (2022a) Stephanie CY Chan, Ishita Dasgupta, Junkyung Kim, Dharshan Kumaran, Andrew K Lampinen, and Felix Hill.  Transformers generalize differently from information stored in context vs in weights.  In _NeurIPS Workshop on Memory in Artificial and Real Intelligence (MemARI)_ , New Orleans, LA, USA, November 2022a.
  * Chan et al. (2022b) Stephanie CY Chan, Adam Santoro, Andrew Kyle Lampinen, Jane X Wang, Aaditya K Singh, Pierre Harvey Richemond, James McClelland, and Felix Hill.  Data distributional properties drive emergent in-context learning in transformers.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , New Orleans, LA, USA, November 2022b.
  * Choromanski et al. (2021) Krzysztof Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamas Sarlos, Peter Hawkins, Jared Davis, Afroz Mohiuddin, Lukasz Kaiser, et al.  Rethinking attention with performers.  In _Int. Conf. on Learning Representations (ICLR)_ , Virtual only, 2021.
  * Coda-Forno et al. (2023) Julian Coda-Forno, Marcel Binz, Zeynep Akata, Matthew Botvinick, Jane X Wang, and Eric Schulz.  Meta-in-context learning in large language models.  _Preprint arXiv:2305.12907_ , 2023.
  * Cotter & Conwell (1990) Neil E Cotter and Peter R Conwell.  Fixed-weight networks can learn.  In _Proc. Int. Joint Conf. on Neural Networks (IJCNN)_ , pp. 553–559, San Diego, CA, USA, June 1990.
  * Cotter & Conwell (1991) Neil E Cotter and Peter R Conwell.  Learning algorithms and fixed dynamics.  In _Proc. Int. Joint Conf. on Neural Networks (IJCNN)_ , pp. 799–801, Seattle, WA, USA, July 1991.
  * Csordás et al. (2021) Róbert Csordás, Kazuki Irie, and Jürgen Schmidhuber.  The devil is in the detail: Simple tricks improve systematic generalization of transformers.  In _Proc. Conf. on Empirical Methods in Natural Language Processing (EMNLP)_ , Punta Cana, Dominican Republic, November 2021.
  * Dai et al. (2023) Damai Dai, Yutao Sun, Li Dong, Yaru Hao, Shuming Ma, Zhifang Sui, and Furu Wei.  Why can GPT learn in-context? language models secretly perform gradient descent as meta-optimizers.  In _Proc. Findings Association for Computational Linguistics (ACL)_ , pp. 4005–4019, Toronto, Canada, July 2023.
  * Deleu et al. (2019) Tristan Deleu, Tobias Würfl, Mandana Samiei, Joseph Paul Cohen, and Yoshua Bengio.  Torchmeta: A meta-learning library for PyTorch.  _Preprint arXiv:1909.06576_ , 2019.
  * Duan et al. (2016) Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel.  RL2: Fast reinforcement learning via slow reinforcement learning.  _Preprint arXiv:1611.02779_ , 2016.
  * Eagleman (2020) David Eagleman.  _Livewired: The inside story of the ever-changing brain_.  2020\.
  * Finn & Levine (2018) Chelsea Finn and Sergey Levine.  Meta-learning and universality: Deep representations and gradient descent can approximate any learning algorithm.  In _Int. Conf. on Learning Representations (ICLR)_ , Vancouver, Canada, April 2018.
  * Finn et al. (2017) Chelsea Finn, Pieter Abbeel, and Sergey Levine.  Model-agnostic meta-learning for fast adaptation of deep networks.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 1126–1135, Sydney, Australia, August 2017.
  * Fodor & Pylyshyn (1988) Jerry A Fodor and Zenon W Pylyshyn.  Connectionism and cognitive architecture: A critical analysis.  _Cognition_ , 28(1-2):3–71, 1988.
  * French (1991) Robert M French.  Using semi-distributed representations to overcome catastrophic forgetting in connectionist networks.  In _Proc. Cognitive science society conference_ , volume 1, pp. 173–178, 1991.
  * French (1999) Robert M French.  Catastrophic forgetting in connectionist networks.  _Trends in cognitive sciences_ , 3(4):128–135, 1999.
  * Graves et al. (2017) Alex Graves, Marc G. Bellemare, Jacob Menick, Rémi Munos, and Koray Kavukcuoglu.  Automated curriculum learning for neural networks.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 1311–1320, Sydney, Australia, August 2017.
  * Grossberg (1982) Stephen T Grossberg.  _Studies of mind and brain: Neural principles of learning, perception, development, cognition, and motor control_.  Springer, 1982.
  * He et al. (2019) Xu He, Jakub Sygnowski, Alexandre Galashov, Andrei A Rusu, Yee Whye Teh, and Razvan Pascanu.  Task agnostic continual learning via meta learning.  _Preprint arXiv:1906.05201_ , 2019.
  * Hochreiter et al. (2001) Sepp Hochreiter, A. Steven Younger, and Peter R. Conwell.  Learning to learn using gradient descent.  In _Proc. Int. Conf. on Artificial Neural Networks (ICANN)_ , volume 2130, pp. 87–94, Vienna, Austria, August 2001.
  * Hsu et al. (2018) Yen-Chang Hsu, Yen-Cheng Liu, Anita Ramasamy, and Zsolt Kira.  Re-evaluating continual learning scenarios: A categorization and case for strong baselines.  In _NeurIPS Workshop on Continual Learning_ , Montréal, Canada, December 2018.
  * Huisman et al. (2023) Mike Huisman, Thomas M Moerland, Aske Plaat, and Jan N van Rijn.  Are LSTMs good few-shot learners?  _Machine Learning_ , pp. 1–28, 2023.
  * Ioffe & Szegedy (2015) Sergey Ioffe and Christian Szegedy.  Batch normalization: Accelerating deep network training by reducing internal covariate shift.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 448–456, Lille, France, July 2015.
  * Irie & Schmidhuber (2023a) Kazuki Irie and Jürgen Schmidhuber.  Accelerating neural self-improvement via bootstrapping.  In _ICLR Workshop on Mathematical and Empirical Understanding of Foundation Models_ , Kigali, Rwanda, May 2023a.
  * Irie & Schmidhuber (2023b) Kazuki Irie and Jürgen Schmidhuber.  Images as weight matrices: Sequential image generation through synaptic learning rules.  In _Int. Conf. on Learning Representations (ICLR)_ , Kigali, Rwanda, May 2023b.
  * Irie et al. (2021a) Kazuki Irie, Imanol Schlag, Róbert Csordás, and Jürgen Schmidhuber.  Going beyond linear transformers with recurrent fast weight programmers.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , Virtual only, December 2021a.
  * Irie et al. (2021b) Kazuki Irie, Imanol Schlag, Róbert Csordás, and Jürgen Schmidhuber.  Improving baselines in the wild.  In _Workshop on Distribution Shifts, NeurIPS_ , Virtual only, 2021b.
  * Irie et al. (2022a) Kazuki Irie, Róbert Csordás, and Jürgen Schmidhuber.  The dual form of neural networks revisited: Connecting test time predictions to training patterns via spotlights of attention.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , Baltimore, MD, USA, July 2022a.
  * Irie et al. (2022b) Kazuki Irie, Francesco Faccio, and Jürgen Schmidhuber.  Neural differential equations for learning to program neural nets through continuous learning rules.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , New Orleans, LA, USA, December 2022b.
  * Irie et al. (2022c) Kazuki Irie, Imanol Schlag, Róbert Csordás, and Jürgen Schmidhuber.  A modern self-referential weight matrix that learns to modify itself.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 9660–9677, Baltimore, MA, USA, July 2022c.
  * Irie et al. (2023) Kazuki Irie, Róbert Csordás, and Jürgen Schmidhuber.  Practical computational power of linear transformers and their recurrent and self-referential extensions.  In _Proc. Conf. on Empirical Methods in Natural Language Processing (EMNLP)_ , Sentosa, Singapore, 2023.
  * Javed & White (2019) Khurram Javed and Martha White.  Meta-learning representations for continual learning.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 1818–1828, Vancouver, BC, Canada, December 2019.
  * Katharopoulos et al. (2020) Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and François Fleuret.  Transformers are RNNs: Fast autoregressive transformers with linear attention.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , Virtual only, July 2020.
  * Kirkpatrick et al. (2017) James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al.  Overcoming catastrophic forgetting in neural networks.  _Proc. National academy of sciences_ , 114(13):3521–3526, 2017.
  * Kirsch & Schmidhuber (2021) Louis Kirsch and Jürgen Schmidhuber.  Meta learning backpropagation and improving it.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 14122–14134, Virtual only, December 2021.
  * Kirsch et al. (2022) Louis Kirsch, James Harrison, Jascha Sohl-Dickstein, and Luke Metz.  General-purpose in-context learning by meta-learning transformers.  In _NeurIPS Workshop on Memory in Artificial and Real Intelligence (MemARI)_ , New Orleans, LA, USA, November 2022.
  * Kortge (1990) Chris A Kortge.  Episodic memory in connectionist networks.  In _12th Annual Conference. CSS Pod_ , pp. 764–771, 1990.
  * Krizhevsky (2009) Alex Krizhevsky.  Learning multiple layers of features from tiny images.  Master’s thesis, Computer Science Department, University of Toronto, 2009.
  * Lake et al. (2015) Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum.  Human-level concept learning through probabilistic program induction.  _Science_ , 350(6266):1332–1338, 2015.
  * LeCun et al. (1998) Yann LeCun, Corinna Cortes, and Christopher JC Burges.  The MNIST database of handwritten digits.  URL http://yann. lecun. com/exdb/mnist, 1998.
  * Li & Hoiem (2016) Zhizhong Li and Derek Hoiem.  Learning without forgetting.  In _Proc. European Conf. on Computer Vision (ECCV)_ , pp. 614–629, Amsterdam, Netherlands, October 2016.
  * Lopez-Paz & Ranzato (2017) David Lopez-Paz and Marc’Aurelio Ranzato.  Gradient episodic memory for continual learning.  In _Proc. Advances in Neural Information Processing Systems (NIPS)_ , pp. 6467–6476, Long Beach, CA, USA, December 2017.
  * McClelland et al. (1995) James L McClelland, Bruce L McNaughton, and Randall C O’Reilly.  Why there are complementary learning systems in the hippocampus and neocortex: insights from the successes and failures of connectionist models of learning and memory.  _Psychological review_ , 102(3):419, 1995.
  * McCloskey & Cohen (1989) Michael McCloskey and Neal J Cohen.  Catastrophic interference in connectionist networks: The sequential learning problem.  In _Psychology of learning and motivation_ , volume 24, pp. 109–165. 1989.
  * Miconi et al. (2018) Thomas Miconi, Kenneth Stanley, and Jeff Clune.  Differentiable plasticity: training plastic neural networks with backpropagation.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 3559–3568, Stockholm, Sweden, July 2018.
  * Miconi et al. (2019) Thomas Miconi, Aditya Rawal, Jeff Clune, and Kenneth O. Stanley.  Backpropamine: training self-modifying neural networks with differentiable neuromodulated plasticity.  In _Int. Conf. on Learning Representations (ICLR)_ , New Orleans, LA, USA, May 2019.
  * Min et al. (2022) Sewon Min, Xinxi Lyu, Ari Holtzman, Mikel Artetxe, Mike Lewis, Hannaneh Hajishirzi, and Luke Zettlemoyer.  Rethinking the role of demonstrations: What makes in-context learning work?  In _Proc. Conf. on Empirical Methods in Natural Language Processing (EMNLP)_ , pp. 11048–11064, Abu Dhabi, UAE, December 2022.
  * Mishra et al. (2018) Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel.  A simple neural attentive meta-learner.  In _Int. Conf. on Learning Representations (ICLR)_ , Vancouver, Cananda, 2018.
  * Munkhdalai & Trischler (2018) Tsendsuren Munkhdalai and Adam Trischler.  Metalearning with Hebbian fast weights.  _Preprint arXiv:1807.05076_ , 2018.
  * Munkhdalai & Yu (2017) Tsendsuren Munkhdalai and Hong Yu.  Meta networks.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 2554–2563, Sydney, Australia, August 2017.
  * Munkhdalai et al. (2019) Tsendsuren Munkhdalai, Alessandro Sordoni, Tong Wang, and Adam Trischler.  Metalearned neural memory.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 13310–13321, Vancouver, Canada, December 2019.
  * Naik & Mammone (1992) Devang K Naik and Richard J Mammone.  Meta-neural networks that learn by learning.  In _Proc. International Joint Conference on Neural Networks (IJCNN)_ , volume 1, pp. 437–442, Baltimore, MD, USA, June 1992.
  * Oreshkin et al. (2018) Boris N. Oreshkin, Pau Rodríguez López, and Alexandre Lacoste.  TADAM: task dependent adaptive metric for improved few-shot learning.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 719–729, Montréal, Canada, December 2018.
  * Peng et al. (2021) Hao Peng, Nikolaos Pappas, Dani Yogatama, Roy Schwartz, Noah A Smith, and Lingpeng Kong.  Random feature attention.  In _Int. Conf. on Learning Representations (ICLR)_ , Virtual only, 2021.
  * Radford et al. (2019) Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever.  Language models are unsupervised multitask learners.  [Online]. : https://blog.openai.com/better-language-models/, 2019.
  * Ratcliff (1990) Roger Ratcliff.  Connectionist models of recognition memory: constraints imposed by learning and forgetting functions.  _Psychological review_ , 97(2):285, 1990.
  * Ravi & Larochelle (2017) Sachin Ravi and Hugo Larochelle.  Optimization as a model for few-shot learning.  In _Int. Conf. on Learning Representations (ICLR)_ , Toulon, France, April 2017.
  * Requeima et al. (2019) James Requeima, Jonathan Gordon, John Bronskill, Sebastian Nowozin, and Richard E. Turner.  Fast and flexible multi-task classification using conditional neural adaptive processes.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 7957–7968, Vancouver, Canada, December 2019.
  * Riemer et al. (2019) Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro.  Learning to learn without forgetting by maximizing transfer and minimizing interference.  In _Int. Conf. on Learning Representations (ICLR)_ , New Orleans, LA, USA, May 2019.
  * Ring (1994) Mark B. Ring.  _Continual Learning in Reinforcement Environments_.  PhD thesis, University of Texas at Austin, Austin, TX, USA, 1994.
  * Robins (1995) Anthony Robins.  Catastrophic forgetting, rehearsal and pseudorehearsal.  _Connection Science_ , 7(2):123–146, 1995.
  * Rolnick et al. (2019) David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy P. Lillicrap, and Gregory Wayne.  Experience replay for continual learning.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 348–358, Vancouver, Canada, December 2019.
  * Rusu et al. (2016) Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell.  Progressive neural networks.  _Preprint arXiv:1606.04671_ , 2016.
  * Sandler et al. (2021) Mark Sandler, Max Vladymyrov, Andrey Zhmoginov, Nolan Miller, Tom Madams, Andrew Jackson, and Blaise Agüera y Arcas.  Meta-learning bidirectional update rules.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 9288–9300, Virtual only, July 2021.
  * Santoro et al. (2016) Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap.  Meta-learning with memory-augmented neural networks.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 1842–1850, New York City, NY, USA, June 2016.
  * Schlag et al. (2021) Imanol Schlag, Kazuki Irie, and Jürgen Schmidhuber.  Linear Transformers are secretly fast weight programmers.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , Virtual only, July 2021.
  * Schmidhuber (1987) Jürgen Schmidhuber.  _Evolutionary principles in self-referential learning, or on learning how to learn: the meta-meta-… hook_.  PhD thesis, Technische Universität München, 1987.
  * Schmidhuber (1990) Jürgen Schmidhuber.  Making the world differentiable: On using fully recurrent self-supervised neural networks for dynamic reinforcement learning and planning in non-stationary environments.  _Institut für Informatik, Technische Universität München. Technical Report FKI-126_ , 90, 1990.
  * Schmidhuber (1991) Jürgen Schmidhuber.  Learning to control fast-weight memories: An alternative to recurrent nets.  Technical Report FKI-147-91, Institut für Informatik, Technische Universität München, March 1991.
  * Schmidhuber (1992a) Jürgen Schmidhuber.  Steps towards “self-referential” learning.  Technical Report CU-CS-627-92, Dept. of Comp. Sci., University of Colorado at Boulder, November 1992a.
  * Schmidhuber (1992b) Jürgen Schmidhuber.  Learning to control fast-weight memories: An alternative to dynamic recurrent networks.  _Neural Computation_ , 4(1):131–139, 1992b.
  * Schmidhuber (1993) Jürgen Schmidhuber.  A self-referential weight matrix.  In _Proc. Int. Conf. on Artificial Neural Networks (ICANN)_ , pp. 446–451, Amsterdam, Netherlands, September 1993.
  * Schmidhuber (1994) Jürgen Schmidhuber.  On learning how to learn learning strategies.  Technical Report FKI-198-94, Institut für Informatik, Technische Universität München, November 1994.
  * Schmidhuber (1995) Jürgen Schmidhuber.  Beyond “genetic programming”: Incremental self-improvement.  In _Proc. Workshop on Genetic Programming at ML95_ , pp. 42–49, 1995.
  * Schmidhuber (2018) Jürgen Schmidhuber.  One big net for everything.  _Preprint arXiv:1802.08864_ , 2018.
  * Schmidhuber et al. (1997) Jürgen Schmidhuber, Jieyu Zhao, and Marco Wiering.  Shifting inductive bias with success-story algorithm, adaptive Levin search, and incremental self-improvement.  _Machine Learning_ , 28(1):105–130, 1997.
  * Schwarz et al. (2018) Jonathan Schwarz, Wojciech Czarnecki, Jelena Luketina, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell.  Progress & compress: A scalable framework for continual learning.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 4535–4544, Stockholm, Sweden, July 2018.
  * Shin et al. (2017) Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim.  Continual learning with deep generative replay.  In _Proc. Advances in Neural Information Processing Systems (NIPS)_ , pp. 2990–2999, Long Beach, CA, USA, December 2017.
  * Srivastava et al. (2013) Rupesh Kumar Srivastava, Jonathan Masci, Sohrob Kazerounian, Faustino J. Gomez, and Jürgen Schmidhuber.  Compete to compute.  In _Proc. Advances in Neural Information Processing Systems (NIPS)_ , pp. 2310–2318, Lake Tahoe, NV, USA, December 2013.
  * Thrun (1998) Sebastian Thrun.  Lifelong learning algorithms.  In _Learning to learn_ , pp. 181–209. 1998.
  * Tolstikhin et al. (2021) Ilya O. Tolstikhin, Neil Houlsby, Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Thomas Unterthiner, Jessica Yung, Andreas Steiner, Daniel Keysers, Jakob Uszkoreit, Mario Lucic, and Alexey Dosovitskiy.  MLP-Mixer: An all-MLP architecture for vision.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , pp. 24261–24272, Virtual only, December 2021.
  * Triantafillou et al. (2020) Eleni Triantafillou, Tyler Zhu, Vincent Dumoulin, Pascal Lamblin, Utku Evci, Kelvin Xu, Ross Goroshin, Carles Gelada, Kevin Swersky, Pierre-Antoine Manzagol, and Hugo Larochelle.  Meta-dataset: A dataset of datasets for learning to learn from few examples.  In _Int. Conf. on Learning Representations (ICLR)_ , Addis Ababa, Ethiopia, April 2020.
  * Ulyanov et al. (2016) Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky.  Instance normalization: The missing ingredient for fast stylization.  _Preprint arXiv:1607.08022_ , 2016.
  * Van de Ven & Tolias (2018a) Gido M Van de Ven and Andreas S Tolias.  Generative replay with feedback connections as a general strategy for continual learning.  _Preprint arXiv:1809.10635_ , 2018a.
  * Van de Ven & Tolias (2018b) Gido M Van de Ven and Andreas S Tolias.  Three scenarios for continual learning.  In _NeurIPS Workshop on Continual Learning_ , Montréal, Canada, December 2018b.
  * Vaswani et al. (2017) Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin.  Attention is all you need.  In _Proc. Advances in Neural Information Processing Systems (NIPS)_ , pp. 5998–6008, Long Beach, CA, USA, December 2017.
  * Veniat et al. (2021) Tom Veniat, Ludovic Denoyer, and Marc’Aurelio Ranzato.  Efficient continual learning with modular networks and task-driven priors.  In _Int. Conf. on Learning Representations (ICLR)_ , Virtual only, May 2021.
  * Vinyals et al. (2016) Oriol Vinyals, Charles Blundell, Tim Lillicrap, Koray Kavukcuoglu, and Daan Wierstra.  Matching networks for one shot learning.  In _Proc. Advances in Neural Information Processing Systems (NIPS)_ , pp. 3630–3638, Barcelona, Spain, December 2016.
  * von Oswald et al. (2023a) Johannes von Oswald, Eyvind Niklasson, Ettore Randazzo, João Sacramento, Alexander Mordvintsev, Andrey Zhmoginov, and Max Vladymyrov.  Transformers learn in-context by gradient descent.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , Honolulu, HI, USA, July 2023a.
  * von Oswald et al. (2023b) Johannes von Oswald, Eyvind Niklasson, Maximilian Schlegel, Seijin Kobayashi, Nicolas Zucchet, Nino Scherrer, Nolan Miller, Mark Sandler, Max Vladymyrov, Razvan Pascanu, et al.  Uncovering mesa-optimization algorithms in Transformers.  _Preprint arXiv:2309.05858_ , 2023b.
  * Wang et al. (2017) Jane Wang, Zeb Kurth-Nelson, Hubert Soyer, Joel Z. Leibo, Dhruva Tirumala, Rémi Munos, Charles Blundell, Dharshan Kumaran, and Matt M. Botvinick.  Learning to reinforcement learn.  In _Proc. Annual Meeting of the Cognitive Science Society (CogSci)_ , London, UK, July 2017.
  * Widrow & Hoff (1960) Bernard Widrow and Marcian E Hoff.  Adaptive switching circuits.  In _Proc. IRE WESCON Convention Record_ , pp. 96–104, Los Angeles, CA, USA, August 1960.
  * Xiao et al. (2017) Han Xiao, Kashif Rasul, and Roland Vollgraf.  Fashion-MNIST: a novel image dataset for benchmarking machine learning algorithms.  _Preprint arXiv:1708.07747_ , 2017.
  * Xie et al. (2022) Sang Michael Xie, Aditi Raghunathan, Percy Liang, and Tengyu Ma.  An explanation of in-context learning as implicit bayesian inference.  In _Int. Conf. on Learning Representations (ICLR)_ , Virtual only, April 2022.
  * Yap et al. (2021) Pau Ching Yap, Hippolyt Ritter, and David Barber.  Addressing catastrophic forgetting in few-shot problems.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 11909–11919, Virtual only, July 2021.
  * Yoo et al. (2022) Kang Min Yoo, Junyeob Kim, Hyuhng Joon Kim, Hyunsoo Cho, Hwiyeol Jo, Sang-Woo Lee, Sang-goo Lee, and Taeuk Kim.  Ground-truth labels matter: A deeper look into input-label demonstrations.  In _Proc. Conf. on Empirical Methods in Natural Language Processing (EMNLP)_ , pp. 2422–2437, Abu Dhabi, UAE, December 2022.
  * Younger et al. (1999) A Steven Younger, Peter R Conwell, and Neil E Cotter.  Fixed-weight on-line learning.  _IEEE Transactions on Neural Networks_ , 10(2):272–283, 1999.
  * Zenke et al. (2017) Friedemann Zenke, Ben Poole, and Surya Ganguli.  Continual learning through synaptic intelligence.  In _Proc. Int. Conf. on Machine Learning (ICML)_ , pp. 3987–3995, Sydney, Australia, August 2017.
  * Zhang et al. (2022) Yaqian Zhang, Bernhard Pfahringer, Eibe Frank, Albert Bifet, Nick Jin Sean Lim, and Yunzhe Jia.  A simple but strong baseline for online continual learning: Repeated augmented rehearsal.  In _Proc. Advances in Neural Information Processing Systems (NeurIPS)_ , New Orleans, LA, USA, December 2022.

##  Appendix A Experimental Details

###  A.1 Continual and meta-learning Terminologies

Here we review the following classic terminologies of continual learning and
meta-learning used throughout this paper.

#### Continual learning.

“Domain-incremental learning (DIL)” and “class-incremental learning (CIL)” are
two classic settings in continual learning (Van de Ven & Tolias, 2018a; b; Hsu
et al., 2018). They differ as follows. Let $M$ and $N$ denote positive
integers. Consider continual learning of $M$ tasks where each task is an
$N$-way classification. In the DIL case, a model has an $N$-way output
classification layer, i.e., the class ‘0’ of the first task shares the same
weights as the class ‘0’ of the second task, and so on. In the CIL case, a
model’s output dimension is $N*M$; the class indices of different tasks are
not shared, neither are the corresponding weights in the output layer. In our
experiments, all CIL models have the $(N*M)$-way output from the first task
(instead of progressively increasing the output size). In this work, we skip
the third variant called “task-incremental learning” which assumes that we
have access to the task identity as an extra input, as it makes the CL problem
almost trivial. CIL is typically reported to be the hardest setting among
them.

#### Meta-learning.

We need to introduce “meta-training” and “meta-test” terminologie since each
of these phases involve “training/test” processes within itself. Each of them
requires the corresponding training and test examples. We refer to these as
“meta-training training/test examples”, and “meta-test training/test examples”
following the terminology of Beaulieu et al. (2020). While these are rather
“heavy” terminologies, they are unambiguous and help avoid potential
confusions. In both phases, our sequence-processing neural net observes a
sequence of (meta-training or meta-test) training examples—each consisting of
input features and a correct label—, and the resulting states of the sequence
processor (i.e., weights in the case of SRWM) are used to make predictions on
(meta-training or meta-test) test examples—input features presented to the
model without its label. During the meta-training phase, we modify the
trainable parameters of the meta-learner through gradient descent minimizing
the meta-learning loss function (using backpropagation through time). During
meta-testing, no human-designed optimization for weight modification is used
anymore; the SRWMs modify their own weights following their own learning rules
defined as their forward pass (Eqs. 1-3). In connection with the now-popular
in-context learning (Brown et al., 2020), we also refer to a (meta-training or
meta-test) training-example sequence as context.

###  A.2 Datasets

For classic image classification datasets such as MNIST (LeCun et al., 1998),
CIFAR10 (Krizhevsky, 2009), and FashionMNIST (FMNIST; Xiao et al. (2017)) we
refer to the original references for details.

For Omniglot (Lake et al., 2015), we use Vinyals et al. (2016)’s
1028/172/432-split for the train/validation/test set, as well as their data
augmentation methods using rotation of 90, 180, and 270 degrees. Original
images are grayscale hand-written characters from 50 different alphabets.
There are 1632 different classes with 20 examples for each class.

Mini-ImageNet contains color images from 100 classes with 600 examples for
each class. We use the standard train/valid/test class splits of 64/16/20
following (Ravi & Larochelle, 2017).

FC100 is based on CIFAR100 (Krizhevsky, 2009). 100 color image classes (600
images per class, each of size $32\times 32$) are split into train/valid/test
classes of 60/20/20 (Oreshkin et al., 2018).

We use torchmeta (Deleu et al., 2019) which provides common few-shot/meta
learning settings for these datasets to sample and construct their meta-
train/test datasets. The construction of “meta-training training” sequences
for an $N$-way classification, using a dataset containing $C$ classes works as
follows; for each sequence, we sample $N$ random but distinct classes out of
$C$ ($N<C$). The resulting classes are re-labelled such that each class is
assigned to one out of $N$ distinct random label index which is unique to the
sequence. For each of these $N$ classes, we sample $K$ examples. We randomly
order these $N*K$ examples to obtain a sequence. Each such a sequence
“simulates” an unknown task the model has to learn.

###  A.3 Hyper-Parameters

We use the same model and training hyper-parameters in all our experiments.
All hyper-parameters are summarized in Table 5. We use the Adam optimizer with
the standard Transformer learning rate warmup scheduling (Vaswani et al.,
2017). The vision backend is the classic 4-layer convolutional NN of Vinyals
et al. (2016). Most configurations follow those of Irie et al. (2022c); except
that we initialize the ‘query’ sub-matrix in the self-referential weight
matrix using a normal distribution with a mean value of 0 and standard
deviation of $0.01/\sqrt{d_{\text{head}}}$ while other sub-matrices use an std
of $1/\sqrt{d_{\text{head}}}$ (motivated by the fact that a generated query
vector is immediately multiplied with the same SRWM to produce a value
vector). For any further details, we’ll refer the readers to our public code
we’ll release upon acceptance.

Table 5:  Hyper-parameters.  Parameters | Values
---|---
Number of SRWM layers | 2
Total hidden size | 256
Feedforward block multiplier | 2
Number of heads | 16
Batch size | 16 or 32

###  A.4 Evaluation Procedure

For evaluation on few-shot learning datasets (i.e., Omniglot, Mini-Imagenet
and FC100), we use 5 different sets consisting of 32 K random test episodes
each, and report mean and standard deviation.

For evaluation on standard datasets, we use 5 different random support sets
for in-context learning, and evaluate on the entire test set. We report the
corresponding mean and standard deviation across these 5 evaluation runs.

For the Split-MNIST experiment, we do 10 meta-testing runs to compute the mean
and standard deviation as the baseline models are also trained for 10 runs in
Hsu et al. (2018) (see other details in Appendix A.7.

###  A.5 Three-Task ACL

We can straightforwardly extend the 2-task version of ACL presented in Sec. 3
to more tasks. In the 3-task case (we denote the three tasks as
${\mathbf{A}}$, ${\mathbf{B}}$, and ${\mathbf{C}}$) used in Sec. 4.3, the
objective function contains six terms. Following three terms are added to Eq.
4:

$\displaystyle-\left(\log(p(y^{\mathcal{C}}_{\text{test}}|{\bm{x}}^{\mathcal{C}}_{\text{test}};{\bm{W}}_{\mathcal{A,B,C}}))+\log(p(y^{\mathcal{B}}_{\text{test}}|{\bm{x}}^{\mathcal{B}}_{\text{test}};{\bm{W}}_{\mathcal{A,B,C}}))+\log(p(y^{\mathcal{A}}_{\text{test}}|{\bm{x}}^{\mathcal{A}}_{\text{test}};{\bm{W}}_{\mathcal{A,B,C}}))\right)$
(5)

This also naturally extends to the 5-task loss used in the Split-MNIST
experiment (Table 3). As one can observe, the number of terms
rapidly/quadratically increases with the number of tasks. Nevertheless,
computing these loss terms isn’t immediately impractical because they
essentially just require forwarding the network for one step, for many
independent inputs/images. This can be heavily parallelized as a batch
operation. While this can be a concern when scaling up more, a natural open
research question is whether we really need all these terms in the case we
have many more tasks. Our experiments effectively show that using more terms
in the ACL loss improves performance. That said, ideally, we want these models
to ‘systematically generalize’ to more tasks even when they are trained with
only a handful of them (Fodor & Pylyshyn, 1988). This as an interesting
research question on generalization to be studied in a future work.

###  A.6 Auxiliary 1-shot Learning Objective

In practice, instead of training the models only for “15-shot learning,” we
also add an auxiliary loss for 1-shot learning. This naturally encourages the
models to learn in-context from the first examples.

###  A.7 Details of the Split-MNIST experiment

Here we provide details of the Split-MNIST experiments presented in Sec. 4 and
Table 3.

Split-MNIST is obtained by transforming the classic 10-class single-task MNIST
dataset into a sequence of 5 tasks by partitioning the 10 classes into 5
groups/pairs of two classes each, in a fixed order from 0 to 9 (i.e., grouping
0/1, 2/3, 4/5, 6/7, and 8/9). For the difference between domain/class-
incremental settings, we refer to Appendix A.1.

The baseline methods presented in Table 3 include: standard SGD and Adam
optimizers, Adam with the L2 regularization, elastic weight consolidation
(Kirkpatrick et al., 2017) and its online variant (Schwarz et al., 2018),
synaptic intelligence (Zenke et al., 2017), memory aware synapses (Aljundi et
al., 2018), learning without forgetting (LwF; Li & Hoiem (2016)). For these
methods, we directly take the numbers reported in Hsu et al. (2018) for the
5-task domain/class-incremental settings.

For the 2-task class incremental setting, we use Hsu et al. (2018)’s code to
train the correspond models (the number for LwF is currently missing as it is
not implemented in their code base; we will add the corresponding/missing
entry in Table 3 for the final version of this paper).

Finally we also evaluate a MAML-based meta-learning approach, OML (Javed &
White, 2019). We note that as reported by Javed & White (2019) in their public
code repository; after some critical bug fix, the performance of their OML
matches that of Beaulieu et al. (2020) (which is a direct application of OML
to another model architecture). Therefore, we focus on OML as our main meta-
continual learning baseline. We take the out-of-the-box model (meta-trained
for Omniglot, with a 1000-way output) made publicly available by (Javed &
White, 2019). We evaluate the corresponding model in two ways. In the first,
‘out-of-the-box’ case, we take the meta-pre-trained model and only tune its
meta-testing learning rate (which is done by Javed & White (2019) even for
meta-testing in Omniglot). We find that this setting does not perform very
well; in the other case (‘optimized # meta-testing iterations’), we
additionally tune the number of meta-test training iterations. We’ve done a
grid search of the meta-test learning rate in
$3*\\{1e^{-2},1e^{-3},1e^{-4},1e^{-5}\\}$ and the number of meta-test training
steps in $\\{1,2,5,8,10\\}$ using a meta-validation set based on an MNIST
validation set (5 K held-out images from the training set); we found the
learning rate of $3e^{-4}$ and $8$ steps to consistently perform the best in
all our settings. We’ve also tried it ‘with’ and ‘without’ the standard
mean/std normalization of the MNIST dataset; better performance was achieved
without such normalization (which is in fact consistent as they do not
normalize the Omniglot dataset for their meta-training/testing). Their
performance on the 5-task class-incremental setting is somewhat
surprising/disappointing (since genenralization from Omniglot to MNIST is
typically straightforward, at least, in common non-continual few-shot learning
settings; see, e.g., Munkhdalai & Yu (2017)). At the same time, to the best of
our knowledge, OML-trained models have not been tested in such a condition in
prior work; from what we observe, the publicly available out-of-the-box model
might be overtuned for Omniglot/Mini-ImageNet or the frozen ‘representation
network’ is not ideal for genenralization. We note that the sensitivity of
these MAML-based methods (Javed & White, 2019; Beaulieu et al., 2020) w.r.t.
meta-test hyper-parameters has been also noted by Banayeeanzade et al. (2021);
these are characteristics of hand-crafted learning algorithms that we want to
avoid with learned learning algorithms.

Unlike any other methods above, our out-of-the-box ACL models (trained on
Omniglot and Mini-ImageNet) do not require any tuning at meta-test time.
Nevertheless, we’ve checked the effect of the number of meta-test training
examples (5 vs. 15; 15 is the number used in meta-training); we found the
consistent number, i.e., 15, to work better than 5. For the version that is
meta-finetuned using the 5-task ACL objective (using only the Omniglot
dataset), we use 5 examples for both meta-train and meta-test training. To
obtain a sequence of 5 tasks, we simply sample 5 tasks from Omniglot (in
principle, we should make sure that different tasks in the same sequence have
no class overlap; in practice, our current implementation simply randomly
draws 5 independent tasks from Omniglot).

##  Appendix B Extra Experimental Results and Comments

###  B.1 Ablation Studies on the choice of meta-validation sets

Here we conduct ablation studies on the choice of meta-validation sets to
select model checkpoints. In general, when dealing with out-of-domain
generalization, the choice of validation procedures to select final model
checkpoints plays a crucial role in the evaluation of the corresponding method
(Csordás et al., 2021; Irie et al., 2021b). The out-of-the-box models are
chosen based on the average meta-validation performance on the validation set
corresponding to the few-shot learning datasets used in meta-training:
Omniglot and mini-ImageNet (or Omniglot, mini-ImageNet, and FC100 in the case
of 3-task ACL), independently of any potential meta-test datasets. In
contrast, in the meta-finetuning process of Table 3, we selected our model
checkpoint by meta-validation on the MNIST validation dataset (we held out 5 K
images from the training set). Here we evaluate ACL models meta-finetuned for
the “5-task domain-incremental binary classification” on three Split-’X’ tasks
where ’X’ is MNIST, FashionMNIST (FMNIST) or CIFAR-10 for various choices of
meta-validation sets (in each case we hold out 5 K images from the
corresponding training set). In addition, we also evaluate the effect of meta-
finetuning datasets (Omniglot only v. Omniglot and mini-ImageNet). Table 6
shows the results (we use 15 meta-training and meta-testing examples except
for the Omniglot-finedtuned/MNIST-validated model from Table 3 which happens
to be configured with 5 examples; this will be fixed in the final version).
Effectively, meta-validation on the matching validation set is useful. Also,
meta-finetuning only on Omniglot is beneficial for the performance on MNIST
when meta-validated on MNIST or FMNIST. However, importantly, we emphasize
that our ultimate goal is not to obtain a model that is specifically tuned for
certain datasets; we aim at building models that generally work well across a
wide range of tasks (ideally on any tasks); in fact, several existing works in
the few-shot learning literature evaluate their methods in such settings (see,
e.g., Requeima et al. (2019); Bronskill et al. (2020); Triantafillou et al.
(2020)). This also goes hand-in-hand with scaling up ACL (our current model is
tiny; see hyper-parameters in Table 5; the vision component is also a shallow
‘Conv-4’ net) and various other considerations on self-improving continual
learners (see, e.g., Schmidhuber (2018)), such as automated curriculum
learning (Graves et al., 2017).

Table 6: Impact of the choice of meta-validation datasets. Classification accuracies (%) on three datasets: Split-CIFAR-10, Split-Fashion MNIST (Split-FMNIST), and Split-MNIST in the domain-incremental setting. “OOB” denotes “out-of-the-box”. “mImageNet” here refers to mini-ImageNet. |  | Meta-Test on Split-
---|---|---
Meta-Finetune Datasets | Meta-Validation Sets | MNIST | FMNIST | CIFAR-10
None (OOB: 2-task ACL; Sec. 4.1) | Omniglot + mImageNet | 72.2 $\pm$ 0.9 | 75.6 $\pm$ 0.7 | 65.3 $\pm$ 1.6
Omniglot | MNIST |  84.3 $\pm$ 1.2 | 78.1 $\pm$ 1.9 | 55.8 $\pm$ 1.2
| FMNIST | 81.6 $\pm$ 1.3 |  90.4 $\pm$ 0.5 | 59.5 $\pm$ 2.1
| CIFAR10 | 75.2 $\pm$ 2.3 | 78.2 $\pm$ 0.9 |  63.4 $\pm$ 1.4
Omniglot + mImageNet | MNIST |  76.6 $\pm$ 1.4 | 85.3 $\pm$ 1.1 | 66.2 $\pm$ 1.1
| FMNIST | 73.2 $\pm$ 2.3 |  89.9 $\pm$ 0.6 | 66.6 $\pm$ 0.7
| CIFAR10 | 76.3 $\pm$ 3.0 | 88.1 $\pm$ 1.3 |  68.6 $\pm$ 0.5

###  B.2 A Comment on Meta-Generalization

We also note that in general, “unseen” datasets do not necessarily imply that
they are harder tasks than “in-domain” test sets; when meta-trained on
Omniglot and mini-ImageNet, meta-generalization on unseen MNIST is easier (the
accuracy is higher) than on the “in-domain” test set of mini-ImageNet with
heldout classes (compare Tables 2 and 2).


* [164] B. Mok, M. Johns, K. J. Lee, D. Miller, D. Sirkin, P. Ive, and W. Ju, “Emergency, automation off: Unstructured transition timing for distracted drivers of automated vehicles,” in _IEEE 18th international conference on intelligent transportation systems_ , 2015, pp. 2458–2464.
  * [165] S. Y. Park, D. J. Moore, and D. Sirkin, “What a driver wants: User preferences in semi-autonomous vehicle decision-making,” in _Proceedings of the CHI Conference on Human Factors in Computing Systems_ , 2020, pp. 1–13.
  * [166] D. W. Eby, L. J. Molnar, L. Zhang, R. M. S. Louis, N. Zanier, L. P. Kostyniuk, and S. Stanciu, “Use, perceptions, and benefits of automotive technologies among aging drivers,” _Injury epidemiology_ , vol. 3, no. 1, p. 28, 2016\.
  * [167] J. Yang and J. F. Coughlin, “In-vehicle technology for self-driving cars: Advantages and challenges for aging drivers,” _International Journal of Automotive Technology_ , vol. 15, no. 2, pp. 333–340, 2014.
  * [168] M. Šucha, “Road users’ strategies and communication: driver-pedestrian interaction,” _Transport Research Arena (TRA)_ , 2014.
  * [169] G. S. Wilde, “Immediate and delayed social interaction in road user behaviour,” _Applied Psychology_ , vol. 29, no. 4, pp. 439–460, 1980.
  * [170] D. Sun, S. Ukkusuri, R. F. Benekohal, and S. T. Waller, “Modeling of motorist-pedestrian interaction at uncontrolled mid-block crosswalks,” in _Transportation Research Record, TRB Annual Meeting CD-ROM, Washington, DC_ , 2003.
  * [171] A. Rasouli and J. K. Tsotsos, “Autonomous vehicles that interact with pedestrians: A survey of theory and practice,” _IEEE Transactions on Intelligent Transportation Systems_ , vol. 21, no. 3, pp. 900–918, 2019.
  * [172] K. Mahadevan, S. Somanath, and E. Sharlin, “Communicating awareness and intent in autonomous vehicle-pedestrian interaction,” in _Proceedings of the CHI Conference on Human Factors in Computing Systems_ , 2018, pp. 1–12.
  * [173] S. M. Faas, S. Mattes, A. C. Kao, and M. Baumann, “Efficient paradigm to measure street-crossing onset time of pedestrians in video-based interactions with vehicles,” _Information_ , vol. 11, no. 7, p. 360, 2020.
  * [174] D. Moore, R. Currano, G. E. Strack, and D. Sirkin, “The case for implicit external human-machine interfaces for autonomous vehicles,” in _Proceedings of the 11th International Conference on Automotive User Interfaces and Interactive Vehicular Applications_ , 2019, pp. 295–307.
  * [175] D. Moore, G. E. Strack, R. Currano, and D. Sirkin, “Visualizing implicit eHMI for autonomous vehicles,” in _Proceedings of the 11th International Conference on Automotive User Interfaces and Interactive Vehicular Applications: Adjunct Proceedings_ , 2019, pp. 475–477.
  * [176] J. Li, R. Currano, D. Sirkin, D. Goedicke, H. Tennent, A. Levine, V. Evers, and W. Ju, “On-road and online studies to investigate beliefs and behaviors of netherlands, us and mexico pedestrians encountering hidden-driver vehicles,” in _Proceedings of the ACM/IEEE International Conference on Human-Robot Interaction_ , 2020, pp. 141–149.
  * [177] A. Z. Asha, C. Smith, L. Oehlberg, S. Somanath, and E. Sharlin, “Views from the wheelchair: Understanding interaction between autonomous vehicle and pedestrians with reduced mobility,” in _Proceedings of the CHI Conference on Human Factors in Computing Systems_ , 2020, pp. 1–8.
  * [178] M. Hou, K. Mahadevan, S. Somanath, E. Sharlin, and L. Oehlberg, “Autonomous vehicle-cyclist interaction: Peril and promise,” in _Proceedings of the CHI Conference on Human Factors in Computing Systems_ , 2020, pp. 1–12.
  * [179] GOV.UK, “Ethics, Transparency and Accountability Framework for Automated Decision-Making.” [Online]. Available: https://www.gov.uk/government/publications/ethics-transparency-and-accountability-framework-for-automated-decision-making
  * [180] Law Commission, “Automated Vehicles: Analysis of Responses to the Preliminary Consultation Paper,” Accessed: July, 5. [Online]. Available: https://www.scotlawcom.gov.uk/files/2815/6093/3787/Automated_Vehicles_-_Analysis_of_Responses_to_the_Preliminary_Consultation_Paper.pdf
  * [181] ——, “What goes into an explanation?” Accessed: July, 5. [Online]. Available: https://ico.org.uk/for-organisations/guide-to-data-protection/key-data-protection-themes/explaining-decisions-made-with-artificial-intelligence/part-1-the-basics-of-explaining-ai/what-goes-into-an-explanation/
  * [182] B. Brehmer and D. Dörner, “Experiments with computer-simulated microworlds: Escaping both the narrow straits of the laboratory and the deep blue sea of the field study,” _Computers in human behavior_ , vol. 9, no. 2-3, pp. 171–184, 1993.
  * [183] A. Jacovi and Y. Goldberg, “Towards Faithfully Interpretable NLP Systems: How should we define and evaluate faithfulness?” _arXiv preprint arXiv:2004.03685_ , 2020.
  * [184] W. G. Najm, J. D. Smith, M. Yanagisawa _et al._ , “Pre-crash scenario typology for crash avoidance research,” United States. National Highway Traffic Safety Administration, Tech. Rep., 2007.
  * [185] M. Gadd, D. De Martini, L. Marchegiani, L. Kunze, and P. Newman, “Sense–Assess–eXplain (SAX): Building Trust in Autonomous Vehicles in Challenging Real-World Driving Scenarios,” in _Proceedings of the IEEE Intelligent Vehicles Symposium (IV), Workshop on Ensuring and Validating Safety for Automated Vehicles (EVSAV)_ , 2020, pp. 150–155.

|  Daniel Omeiza received a bachelors degree in Computer Science from the
University of Ilorin in 2015. He obtained a masters degree in Information
Technology from Carnegie Mellon University in 2019. He is currently working
towards a DPhil degree at the University of Oxford. His research interests
primarily lie in explainability in autonomous driving. He is a student member
of the IEEE.
---|---
|  Helena Webb is a Transitional Assistant Professor in the School of Computer
Science at the University of Nottingham. She is interested in the ways that
users interact with technologies in different kinds of setting and how social
action both shapes and is shaped by innovation. She works on projects that
seek to identify mechanisms for the improved design, responsible development
and effective regulation of technology. She has worked on projects relating
to, amongst others, harmful content on social media, algorithm bias, resource
scarcity in STEM education, human-robot dialogue, and responsible robotics.
She is an interdisciplinary researcher and specialises in the application of
qualitative research methods. She is also very interested in methodological
innovation to combine detailed, granular analysis with larger scale
computational work.
---|---
|  Marina Jirotka is Professor of Human-Centred Computing at the University of
Oxford and Governing Body Fellow at St Cross College. She leads an
interdisciplinary research group developing methods for building computing
systems responsibly to support human, societal and environmental values. The
team focuses on responsible innovation, in a range of ICT fields including
robotics, AI, machine learning, quantum computing, social media and the
digital economy. She is an EPSRC Established Career Fellow conducting a five-
year investigation into Developing Responsible Robotics for the Digital
Economy. She is Director of the newly established Responsible Technology
Institute at Oxford, and she is co-director of the Observatory for Responsible
Research and Innovation in ICT (ORBIT) which provides RI services and training
to ICT researchers and practitioners. She obtained her BSc in Psychology and
Social Anthropology (Hons) from The University of London Goldsmiths College in
1985 and her Masters in Computing and Artificial Intelligence from the
University of South Bank in 1987. Her doctorate in Computer Science, “An
Investigation into Contextual Approaches to Requirements Capture”, was
undertaken at the University of Oxford in 2000.
---|---
|  Lars Kunze is a Departmental Lecturer in Robotics in the Oxford Robotics
Institute (ORI) and the Department of Engineering Science at the University of
Oxford. In the ORI, he leads the Cognitive Robotics Group (CRG). Dr Kunze is
also the Technical Lead at the Responsible Technology Institute (RTI), an
international centre of excellence focused on responsible technology at Oxford
University; and a Programme Fellow of the Assuring Autonomy International
Programme (AAIP). He is a Stipendiary Lecturer in Computer Science at Christ
Church and an Editor of both the Journal of Responsible Technology and the
German Journal of Artificial Intelligence. Before joining Oxford, he was a
Research Fellow in the Intelligent Robotics Lab at Birmingham University. He
studied Cognitive Science (BSc, 2006) and Computer Science (MSc, 2008) at the
University of Osnabrück, Germany, and partly at the University of Edinburgh,
UK. He received a PhD (Dr. rer. nat.) from the Technical University of Munich
in 2014.
---|---