Original: L EARNING TO L EARN WITHOUT F ORGETTING B Y M AXIMIZING T RANSFER AND M INIMIZING I NTERFERENCE
Revised: L EARNING TO L EARN WITHOUT F ORGETTING B Y M AXIMIZING T RANSFER AND M INIMIZING I NTERFERENCE

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Lack of performance when it comes to continual learning over non-stationary distributions of data remains a major challenge in scaling neural network learning to more human realistic settings.
Revised: Lack of performance when it comes to continual learning over non-stationary distributions of data remains a major challenge in scaling neural network learning to more human realistic settings.

Original: In this work we propose a new conceptualization of the continual learning problem in terms of a  trade-off between transfer and interference.
Revised: In this work we propose a new conceptualization of the continual learning problem in terms of a temporally symmetric trade-off between transfer and interference that can be optimized by enforcing gradient alignment across examples.

Original: We then propose a new algorithm, Meta-Experience Replay (MER), that directly exploits this view by combining experience replay with optimization based meta-learning.
Revised: We then propose a new algorithm, Meta-Experience Replay (MER), that directly exploits this view by combining experience replay with optimization based meta-learning.

Original: This method learns parameters that make interference based on future gradients less likely and transfer based on future gradients more likely.
Revised: This method learns parameters that make interference based on future gradients less likely and transfer based on future gradients more likely.

Original:  We conduct experiments across continual lifelong supervised learning benchmarks and non-stationary reinforcement learning environments demonstrating that our approach consistently outperforms recently proposed baselines for continual learning.
Revised: 1 We conduct experiments across continual lifelong supervised learning benchmarks and non-stationary reinforcement learning environments demonstrating that our approach consistently outperforms recently proposed baselines for continual learning.

Original: Our experiments show that the gap between the performance of MER and baseline algorithms grows both as the environment gets more non-stationary and as the fraction of the total experiences stored gets smaller.
Revised: Our experiments show that the gap between the performance of MER and baseline algorithms grows both as the environment gets more non-stationary and as the fraction of the total experiences stored gets smaller.

Original: T HE  S TABILITY -P LASTICITY D ILEMMA AND C ONTINUAL L EARNING 
Revised:  S OLVING THE C ONTINUAL L EARNING P ROBLEM

Original: A long-held goal ofthe AIcommunity is to build agents capable of operating autonomously for long periods.
Revised: A long-held goal of AI is to build agents capable of operating autonomously for long periods.

Original: Such agents must incrementally learn and adapt to a changing environment while maintaining memories of what they have learned before, a setting known as lifelong, or continual learning (Thrun,  1996). 
Revised: Such agents must incrementally learn and adapt to a changing environment while maintaining memories of what they have learned before, a setting known as lifelong learning (Thrun, 1994; 1996). In this paper we explore a variant called continual learning (Ring, 1994).

Original: Over the years, much research in this domain has focused on the stabilityplasticity dilemma (Carpenter & Grossberg, 1987), also referred to as the catastrophic forgetting problem (McCloskey & Cohen, 1989), where an agent must learn a current task without degrading its performance on the previous tasks (Goodrich, 2015). It is often assumed that thethe learner is exposed to a sequence of tasks, where each task is a sequence of (labeled) samples from the same distribution, and the distributions the tasks come from are different (Lopez-Paz & Ranzato, 2017).
Revised: In continual learning we assume that the learner is exposed to a sequence of tasks, where each task is a sequence of experiences from the same distribution (see Appendix A for details). We would like to develop a solution in this setting by discovering notions of tasks without supervision while learning incrementally after every experience.

Original: Given a potentially inﬁnite number of such tasks/distributions in continual learning problem, it is important to consider stability-plasticity trade-off in both forward and backward directions in time (Figure 1).
Revised: This is challenging because in standard ofﬂine single task and multi-task learning (Caruana, 1997) it is implicitly assumed that the data is drawn from an i.i.d. stationary distribution. Unfortunately, neural networks tend to struggle whenever this is not the case (Goodrich, 2015).

Original: Indeed, previously proposed solutions to the catastrophic forgetting problem are not well-suited toaddressing thefull continual learning problem.
Revised: Over the years, solutions to the continual learning problem have been largely driven by prominent conceptualizations of the issues faced by neural networks.

Original: To be speciﬁc, many of those approaches focus on the preservation of past learning by reducing the degree of  neural network weight-sharing across the  past and current tasks (Kirkpatrick et al., 2017; Zenke et al., 2017; Lee et al., 2017). 
Revised: One popular view is catastrophic forgetting (interference) (McCloskey & Cohen, 1989), in which the primary concern is the lack of stability in neural networks, and the main solution is to limit the extent of weight sharing across experiences by focusing on preserving past knowledge (Kirkpatrick et al., 2017; Zenke et al., 2017; Lee et al., 2017). Another popular and more complex conceptualization is the stability-plasticity dilemma (Carpenter & Grossberg, 1987). In this view, the primary concern is the balance between network stability (to preserve past knowledge) and plasticity (to rapidly learn the current experience). For example, these techniques focus on balancing limited weight sharing with some mechanism to ensure fast learning (Li & Hoiem, 2016; Riemer et al., 2016a; Lopez-Paz & Ranzato, 2017; Rosenbaum et al., 2018; Lee et al., 2018; Serr`a et al., 2018).

Original: By only partially sharing weights across tasks, semi-distributed representations are able to overcome the natural recency bias in neural nets and more cleanly segregate past from current learning (French, 1991; Goodrich, 2015; Rosenbaum et al., 2018).
Revised: In this paper, we extend this view by noting that for continual learning over an unbounded number of distributions, we need to consider weight sharing and the stability-plasticity trade-off in both the forward and backward directions in time (Figure 1A). Stability – Plasticity Dilemma Stability – Plasticity Dilemma A. Transfer – Interference Trade-o ﬀ

Original: However, it is still possible that the reduction in weight sharing may worsen future performance on unseen tasks by limiting the networks capacity for forward transfer.
Revised: [Figure] Current Learning Future Learning Sharing

Original: Here we seek to ﬁnd a solution to the more general continual learning problem that also performs well in the more limited stability-plasticity context.
Revised: Sharing B. Transfer C. Interference ∂ L i ∂ θ ∂ L j ∂ θ ∂ L i ∂ θ ∂ L j ∂ θ FUTURE PAST

Original: More speciﬁcally, we propose a new conceptualization of  the continuallifelong learning problem that generalizes the stability-plasticity dilemma to a transfer-interference trade-off that extends into the past and, critically, to the future as well (section 2).
Revised: Transfer [Figure] Interference The transfer-interference trade-off proposed in this paper (section 2) presents a novel perspective on the goal of gradient alignment for the continual learning problem.

Original:  The key difference in perspective with past conceptualizations of continual learning is that we are not just concerned with currentinterference and transfer  with respect to past examples (i.e., the classical stability-plasticity dilemma), but alsoconcerned with the dynamics of transfer and interference moving forward as we learn. 
Revised: This is right at the heart of the problem as these gradients are the update steps for SGD based optimizers during learning and there is a clear connection between gradients angles and managing the extent of weight sharing. The key difference in perspective with past conceptualizations of continual learning is that we are not just concerned with current transfer and interference with respect to past examples, but also with the dynamics of transfer and interference moving forward as we learn. Other approaches have certainly explored operational notions of transfer and interference in forward and backward directions (Lopez-Paz & Ranzato, 2017; Chaudhry et al., 2018), the link to weight sharing (French, 1991; Ajemian et al., 2013), and the idea of inﬂuencing gradient alignment for continual learning before (Lopez-Paz & Ranzato, 2017). However, in past work, adhoc changes have been made to the dynamics of weight sharing based on current learning and past learning without formulating a consistent theory about the optimal weight sharing dynamics.

Original: This perspective inspires a meta-learning formulation of thecontinual learning problem where on top of learning to explain all examples seen, we also regularize our learningso that it learns to make transfermore likely and interferenceless likely in the future.
Revised: This new view of the problem leads to a natural meta-learning (Schmidhuber, 1987) perspective on continual learning: we would like to learn to modify our learning to effect the dynamics of transfer and interference in a general sense.

Original: To the extent that our meta-learning into the future generalizes, this shouldeffectively make it easier for our model toeffectively perform continual learning in non-stationary settings.
Revised: To the extent that our meta-learning into the future generalizes, this should make it easier for our model to perform continual learning in non-stationary settings.

Original: T HE T RANSFER -I NTERFERENCE T RADE - OFF FOR C ONTINUAL L EARNING
Revised: We achieve this by building off past work on experience replay (Murre, 1992; Lin, 1992; Robins, 1995) that has been a mainstay for solving non-stationary problems with neural networks. We propose a novel meta-experience replay (MER) algorithm that combines experience replay with optimization based meta-learning (section 3) as a ﬁrst step towards modeling this perspective. Moreover, our experiments (sections 4, 5, and 6), conﬁrm our theory. MER shows great promise across a variety of supervised continual learning and continual reinforcement learning settings.

Original: Throughout our paper we will discuss ideas in terms of the supervised learning problem formulation.
Revised: Critically, our approach is not reliant on any provided notion of tasks and in most of the settings we explore we must detect the concept of tasks without supervision.

Original: Extensions to the reinforcement learning formulation are straightforward and we provide more details in the appendix.
Revised: See Appendix B for a more detailed positioning with respect to related research.  T HE T RANSFER -I NTERFERENCE T RADE - OFF FOR C ONTINUAL L EARNING

Original: In typical ofﬂine supervised learning with neural networks, we can express our optimization objective in terms of the stationary distribution of x, y pairs within the dataset D.
Revised: At an instant in time with parameters θ and loss L , we can deﬁne 2 operational measures of transfer and interference between two arbitrary distinct examples ( x i , y i ) and ( x j , y j ) while training with

Original: Here we deﬁne the continual learning problem as sampling from a never ending stream of x, y pairs with no knowledge or assumptions about the underlying distributions from which the data are drawn.
Revised: SGD.

Original: The expectation of the loss at any point in time is simply taken over past history and current sample, and we optimize it for all points in the future.
Revised: Transfer occurs when:

Original: [Equation]
Revised: [Equation]

Original: where · is the dot product operator.
Revised: where · is the dot product operator.

Original: This implies that learning example i will without repetition improve performance on example j and vice versa.
Revised: This implies that learning example i will without repetition improve performance on example j and vice versa (Figure 1B).

Original: On the other hand we can say that interference occurs when:
Revised: Interference occurs when:

Original: [Equation]
Revised: [Equation]

Original: This implies in contrast that learning example i will lead to unlearning (i.e. forgetting) of example j and vice versa.
Revised: Here, in contrast, learning example i will lead to unlearning (i.e. forgetting) of example j and vice versa (Figure 1C).

Original:  Past solutionsdescribed in the previous section for the Stability-Plasticity Dilemma in continual learning operate in a simpliﬁed temporal context whereby learning is divided into two phases: all past experiences are lumped together as old memories and the datathat is currently being learned qualiﬁes as new learning .
Revised: The potential for transfer is maximized when weight sharing is maximized while potential for interference is minimized when weight sharing is minimized (Appendix C). Past solutions for the stability-plasticity dilemma in continual learning operate in a simpliﬁed temporal context where learning is divided into two phases: all past experiences are lumped together as old memories and the data currently being learned qualiﬁes as new learning .

Original: In this setting, the goal is to  minimize the interference projecting backward in time, and many of the approaches that succeed in this respect do so by reducing the degree of weight sharing in one form or another.
Revised: In this setting, the goal is to simply minimize the interference projecting backward in time, which is generally achieved by reducing the degree of weight sharing explicitly or implicitly.

Original: However, one need not worry about performance on the current task, because that is what is currently being learned.

Original: Therefore, solving the stabilityplasticity dilemma reduces solely to mitigating interference on the old memories.

Original: In the appendix we explain how our baseline approaches (Kirkpatrick et al., 2017; Lopez-Paz & Ranzato, 2017)each ﬁt within this paradigm.
Revised: In Appendix D we explain how our baseline approaches (Kirkpatrick et al., 2017; Lopez-Paz & Ranzato, 2017) ﬁt within this paradigm.

Original: As one example, the approach EWC in (Kirkpatrick et al., 2017) promotes less sharing of parameters for new learning that were deemed to be important for performance on old memories.

Original: The important issue with this perspective, however, is that the system is not done with learning that will occur in the future, and what the future may bring is largely unknown.
Revised: The important issue with this perspective, however, is that the system still has learning to do and what the future may bring is largely unknown.

Original: This makes it incumbent upon us to do nothing to potentially undermine the networks ability to effectively learn in an uncertain future.
Revised: This makes it incumbent upon us to do nothing to potentially undermine the networks ability to effectively learn in an uncertain future.

Original: This consideration makes us extend the temporal horizon of the stabilityplasticity problem forward, turning it, more generally, into a continual learning problem that we label as solving the Transfer-Interference Trade-off (Figure 1).
Revised: This consideration makes us extend the temporal horizon of the stability-plasticity problem forward, turning it, more generally, into a continual learning problem that we label as solving the Transfer-Interference Trade-off (Figure 1A).

Original: Speciﬁcally, it is important not only to reduce backward interference from our current point in time, but we must do so in a manner that does not limit our ability to learn in the future.
Revised: Speciﬁcally, it is important not only to reduce backward interference from our current point in time, but we must do so in a manner that does not limit our ability to learn in the future.

Original: This more general perspective makes the problem more difﬁcult to solve, because the issue of  weight sharing across tasks arises both backward and forward in time.
Revised: This more general perspective acknowledges a subtlety in the problem: the issue of gradient alignment and thus weight sharing across examples arises both backward and forward in time.

Original: When viewed from this temporally symmetric perspective, the transfer-interference trade-off becomes clear: the weight sharing across tasks that enables transfer to improve future performance must not disrupt performance on what has come previously. This brings us to the central point of the paper: if we mitigate interference by reducing weight-sharing, we are likely to worsen the networks capacity for transfer into the future, since transfer depends precisely on weight sharing: what is the future will eventually become the past, and performance must be good at all points in time. We build off past work on experience replay (Murre, 1992; Lin, 1992; Robins, 1995) that has been a mainstay for solving non-stationary problems with neural networks (i.e. leading to human level performance on many Atari games (Mnih et al., 2015)).
Revised: With this temporally symmetric perspective, the transfer-interference trade-off becomes clear.

Original: We argue that this is because of replays ability to stabilize learning without sacriﬁcing weight-sharing. In section 3.2 we motivate a particularly effective variant of experience replay for continual learning.
Revised: Here we propose a potential solution where we learn to learn in a way that promotes gradient alignment at each point in time. The weight sharing across examples that enables transfer to improve future performance must not disrupt performance on what has come previously.

Original: Then in section 3.3 we describe how we augment this variant of experience replay with meta-learning to derive a new Meta-Experience Replay (MER) algorithm that optimizes for the transfer-interference trade-off. In ourexperiments we demonstrate that MER is quite general, achieving superior sample efﬁcient continual learning performance both in a many task supervised learning setting and within highly non-stationarity RL tasks. In contrast to past work on meta-learning for few shot learning (Santoro et al., 2016; Vinyals et al., 2016; Ravi Larochelle, 2016; Finn et al., 2017) and reinforcement learning across successive tasks (Al-Shedivat et al., 2018)
Revised: As such, our work adopts a meta-learning perspective on the continual learning problem.

Original: we are not trying to simply improve the speed of learning on new data. In this paper we are trying to improve the speed of learning on new data in a way that also preserves knowledge of past data. Critically, our approach also is not reliant on any notion of tasks being provided by humans to  the model. In fact, in most of the settings we explore, we consider the more general case where the model must detect the concept of new tasks on its own without supervision.
Revised: We would like to learn to learn each example in a way that generalizes to other examples from the overall distribution.

Original:  A S YSTEM FOR L EARNING TO L EARN WITHOUT F ORGETTING
Revised:  A S YSTEM FOR L EARNING TO L EARN WITHOUT F ORGETTING

Original: In this section we outline the motivation and details of our approach Meta-Experience Replay (MER) meant to enable general purpose continual learning while efﬁciently solving for the transferinterference trade-off outlined in the last section.

Original: 3. M OTIVATION

Original: In typical ofﬂine supervised learning with neural networks, we can express our optimization objective in terms of the stationary distribution of x, y pairs within the dataset D :
Revised: In typical ofﬂine supervised learning, we can express our optimization objective over the stationary distribution of x, y pairs within the dataset D :

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original:  where L is the loss function, which can be selected to ﬁt the problem.
Revised: ) where L is the loss function, which can be selected to ﬁt the problem.

Original: If we would like to maximize transfer and minimize interference, we can imagine it would be useful to add an auxiliary loss to the objective to bias the learning process in that direction.
Revised: If we would like to maximize transfer and minimize interference, we can imagine it would be useful to add an auxiliary loss to the objective to bias the learning process in that direction.

Original: One obviously beneﬁcial choice would be to also directly consider the gradients with respect to the loss function evaluated at randomly chosen datapoints within the dataset.
Revised: Considering equations 1 and 2, one obviously beneﬁcial choice would be to also directly consider the gradients with respect to the loss function evaluated at randomly chosen datapoints.

Original: If we could maximize the dot products between gradients at these different points, it would directly encourage the network to share parameters where gradient directions align and keep parameters separate that interfere with each other that have gradients in opposite directions.
Revised: If we could maximize the dot products between gradients at these different points, it would directly encourage the network to share parameters where gradient directions align and keep parameters separate where interference is caused by gradients in opposite directions.

Original: So, in an ideal case we would like to optimize for the following objective:
Revised: So, ideally we would like to optimize for the following objective 4 :

Original: [Equation]
Revised: [Equation]

Original: where ( x i , y i ) and ( x j , y j ) are randomly sampled unique data points.

Original: In our work we will attempt to make a continual learning system that optimizes for this objective.

Original: However, there are multiple problems that must be addressed to implement this kind of learning process in practical settings.

Original: The ﬁrst problem is that continual learning deals with learning over a continuous non-stationary stream of data.

Original: We address this by following past work and implementing an experience replay module that augments online learning so that we can approximately optimize over the stationary distribution of all examples seen so far.

Original: Algorithm procedure T RAIN ( D, θ, α, β, γ,  k ) 
Revised: procedure T RAIN ( D, θ, α, β, γ, s, k ) M ← {} for t

Original: M ← {} for t = 1 , ..., T do for ( x, y ) in D t do //
Revised: = 1 , ..., T do for ( x, y ) in D t do //

Original: Draw batches from buffer:
Revised: Draw batches from buffer:

Original: B 1 , ..., B s ← sampleBatches ( x,  k, M ) θ
Revised: B 1 , ..., B s ← sample ( x, y, s, k, M ) θ

Original: A 0 ← θ for i = 1 , ..., s do θ Wi  0 ← θ for j = 1 , ..., k do x c , y c ← B i [ j ] θ Wij ← SGD ( x c , y c , θ Wj − 1 , α ) end for //
Revised: A 0 ← θ for i = 1 , ..., s do θ Wi , 0 ← θ for j = 1 , ..., k do x c , y c ← B i [ j ] θ Wi,j ← SGD ( x c , y c , θ Wi,j − 1 , α ) end for //

Original: Within batch Reptile meta-update: θ ← θ Wi 0 + β ( θ Wik − θ Wi 0 ) 
Revised: Within batch Reptile meta-update: θ ← θ Wi, 0 + β ( θ Wi,k − θ Wi, 0 ) θ

Original: θ Ai ← θ end for //
Revised: Ai ← θ end for //

Original: Across batch Reptile meta-update: θ ← θ A 0 + γ ( θ As − θ A 0 ) //
Revised: Across batch Reptile meta-update: θ ← θ A 0 + γ ( θ As − θ A 0 ) //

Original: Update memory with reservoir sampling: M ← M ∪ { ( x, y, t ) }  end for end for return θ, M end procedure 
Revised: Reservoir sampling memory update: M ← M ∪ { ( x, y ) } (algorithm 3) end for end for return θ, M end procedure where ( x i , y i ) and ( x j , y j ) are randomly sampled unique data points.

Revised: We will attempt to design a continual learning system that optimizes for this objective.

Revised: However, there are multiple problems that must be addressed to implement this kind of learning process in practice.

Revised: The ﬁrst problem is that continual learning deals with learning over a non-stationary stream of data.

Revised: We address this by implementing an experience replay module that augments online learning so that we can approximately optimize over the stationary distribution of all examples seen so far.

Original: Another practical problem is that the gradients of this loss depend on the second derivative with respect to the loss function, which is expensive to compute.
Revised: Another practical problem is that the gradients of this loss depend on the second derivative of the loss function, which is expensive to compute.

Original: We address thisissue by indirectly approximating this objective to a ﬁrst order Taylorseries expansion using an online meta-learning algorithm with minimal computational overhead.
Revised: We address this by indirectly approximating the objective to a ﬁrst order Taylor expansion using a meta-learning algorithm with minimal computational overhead.

Original: 3. E XPERIENCE R EPLAY
Revised: 3. E XPERIENCE R EPLAY

Original: As mentioned above, the continual lifelong learning setting poses a challenge for the optimization of neural networks as examples come one by one in a non-stationary stream.
Revised: Learning objective: The continual lifelong learning setting poses a challenge for the optimization of neural networks as examples come one by one in a non-stationary stream.

Original: We would liketo instead have ourneural network  optimize over the stationary distribution of all example seen so far.
Revised: Instead, we would like our network to optimize over the stationary distribution of all examples seen so far.

Original: Experience replay (Lin, 1992; Murre, 1992) is an old technique that remains a central component of deep learning systems attempting to learn in non-stationary settings. In this paper we  adopt  conventions from recent work (Zhang & Sutton, 2017; Riemer et al., 2017) leveraging this approach.
Revised: Experience replay (Lin, 1992; Murre, 1992) is an old technique that remains a central component of deep learning systems attempting to learn in non-stationary settings, and we will adopt here conventions from recent work (Zhang & Sutton, 2017; Riemer et al., 2017b) leveraging this approach.

Original: The central feature of experience replays is keeping a memory of examples seen M that is interleaved with the training of the current example with the goal of makingthe neural network training more stable.
Revised: The central feature of experience replays is keeping a memory of examples seen M that is interleaved with the training of the current example with the goal of making training more stable.

Original: As a result experience replay approximates the objective in equation 3 to the extent that M approximates D :
Revised: As a result, experience replay approximates the objective in equation 3 to the extent that M approximates D :

Original: [Equation]
Revised: [Equation]

Original: (5) where M has a current size M size and maximum size M max .
Revised: M has a current size M size and maximum size M max .

Original: In our work, we update the buffer with reservoir sampling.
Revised: In our work, we update the buffer with reservoir sampling (Appendix F).

Original: This ensures that at every timestep the probability that any of the N examples seen has of being in the buffer is equal to M size /N .
Revised: This ensures that at every time-step the probability that any of the N examples seen has of being in the buffer is equal to M size /N .

Original: This implies that the contents of the buffer resembles a stationary distribution over all examples seen to the extent that the items stored captures the variation of past examples.
Revised: The content of the buffer resembles a stationary distribution over all examples seen to the extent that the items stored captures the variation of past examples.

Original: Following the standard practice in ofﬂine learning, we train by randomly sampling a batch Bof experiences from the stored distribution.
Revised: Following the standard practice in ofﬂine learning, we train by randomly sampling a batch B from the distribution captured by M .

Original: However, we differ in that the current example has a special role ensuring that it is always interleaved with the examples sampled from the replay buffer.
Revised: Prioritizing the current example: the variant of experience replay we explore differs from ofﬂine learning in that the current example has a special role ensuring that it is always interleaved with the examples sampled from the replay buffer.

Original: Before we proceed to the next example, we want to make surewe provide our algorithm with the ability to optimize for the current example (particularly if it is not added to the memory).
Revised: This is because before we proceed to the next example, we want to make sure our algorithm has the ability to optimize for the current example (particularly if it is not added to the memory).

Original: Over N examples seen
Revised: Over N examples seen

Original: , this still implies that we have trained with each example as the current example with probability per step of 1 /N .
Revised: , this still implies that we have trained with each example as the current example with probability per step of 1 /N .

Original: We provide a detailed algorithm further explaining how experience replay is used in this work in the appendix.
Revised: We provide an algorithm further detailing how experience replay is used in this work in Appendix G (algorithm 4).

Original:  Obviously, it is not scalable to store every experience seen in memory.
Revised: Concerns about storing examples: Obviously, it is not scalable to store every experience seen in memory.

Original: As such, in this work we focus on showing that we can achieve greater performance than baseline techniques when each approach is provided with only a small memory buffer.
Revised: As such, in this work we focus on showing that we can achieve greater performance than baseline techniques when each approach is provided with only a small memory buffer.

Original: 3. M ETA -L EARNING AS A BIAS FOR E XPERIENCE R EPLAY 
Revised: 3. C OMBINING E XPERIENCE R EPLAY WITH O PTIMIZATION B ASED M ETA -L EARNING

Original:  One of the most popular meta-learning algorithms to date is Model Agnostic Meta-Learning (MAML)
Revised: First order meta-learning: One of the most popular meta-learning algorithms to date is Model Agnostic Meta-Learning (MAML)

Original: (Finn et al., 2017).
Revised: (Finn et al., 2017).

Original: MAML requires training and validation splits from a set of tasks to perform meta-training, optimizing the network to ﬁnd a set of initial parameters θ 0 that can easily adapt to a new unseen task when trained on training data from the task. This is done by optimizing the initial parameters with respect to its generalization to the task validation data after training has completed on the training data.
Revised: MAML is an optimization based meta-learning algorithm with nice properties such as the ability to approximate any learning algorithm and the ability to generalize well to learning data outside of the previous distribution (Finn & Levine, 2017).

Original: One aspect of MAML that limits its scalability is the need to explicitly compute second derivatives.
Revised: One aspect of MAML that limits its scalability is the need to explicitly compute second derivatives.

Original: The authors proposed a variant called ﬁrst-order MAML (FOMAML), which is deﬁned by ignoring the second derivative terms to address this issue and surprisingly found that it achieved very similar performance.
Revised: The authors proposed a variant called ﬁrst-order MAML (FOMAML), which is deﬁned by ignoring the second derivative terms to address this issue and surprisingly found that it achieved very similar performance.

Original: Recently, this phenomenon was explained by (Nichol & Schulman, 2018) who noted through Taylor expansion that the two algorithms were approximately optimizing for the same loss function.
Revised: Recently, this phenomenon was explained by (Nichol & Schulman, 2018) who noted through Taylor expansion that the two algorithms were approximately optimizing for the same loss function.

Original: Nichol & Schulman (2018) also proposed an algorithm, Reptile, that efﬁciently optimizes for approximately the same objective while not requiring that the data be split into training and testing splits for each task learned.
Revised: Nichol & Schulman (2018) also proposed an algorithm, Reptile, that efﬁciently optimizes for approximately the same objective while not requiring that the data be split into training and testing splits for each task learned as MAML does.

Original: Reptile is implemented by optimizing across k batches of data sequentially with an SGD based optimizer and learning rate α .
Revised: Reptile is implemented by optimizing across s batches of data sequentially with an SGD based optimizer and learning rate α .

Original: After training on these batches, we take the initial parameters before training θ 0 and update them to θ 0 ← θ 0 + β ∗ ( θ k − θ 0 ) where β is the learning rate for the meta-learning update.
Revised: After training on these batches, we take the initial parameters before training θ 0 and update them to θ 0 ← θ 0 + β ∗ ( θ k − θ 0 ) where β is the learning rate for the meta-learning update.

Original: The process repeats for each series of k batches.
Revised: The process repeats for each series of s batches (algorithm 2).

Original: As shown in terms of gradients in (Nichol & Schulman, 2018), Reptile approximately optimizes for the following objective within a set of k batches:
Revised: Shown in terms of gradients in (Nichol & Schulman, 2018), Reptile approximately optimizes for the following objective over a set of s batches:

Original: [Equation]
Revised: [Equation]

Original: where B 1 , ..., B k are batches within the total dataset.
Revised: where B 1 , ..., B s are batches within D .

Original: Thisobjective isquite appealing and similar to the objective in equation 4 to the extent that gradients produced on these batches approximate samples from the stationary distribution of all examples seen in the past.
Revised: This is similar to our motivation in equation 4 to the extent that gradients produced on these batches approximate samples from the stationary distribution.

Original:  In this work, we modify the Reptile algorithm to properly integrate it with an experience replay module, facilitating continual learning while maximizing transfer and minimizing interference.
Revised: The MER learning objective: In this work, we modify the Reptile algorithm to properly integrate it with an experience replay module, facilitating continual learning while maximizing transfer and minimizing interference.

Original: We describe in more detail during the derivation in the appendix that achieving the Reptile objective in an online setting where examples are provided sequentially is non-trivial and is in part only achievable because of ourrandom sampling strategies for both the buffer and batch.
Revised: As we describe in more detail during the derivation in Appendix I, achieving the Reptile objective in an online setting where examples are provided sequentially is non-trivial and is in part only achievable because of our sampling strategies for both the buffer and batch.

Original: Following our remarks about experience replay from the prior section, this allows us to optimize for the following objective in a continual learning setting using our proposed Meta-Experience Replay (MER) algorithm:
Revised: Following our remarks about experience replay from the prior section, this allows us to optimize for the following objective in a continual learning setting using our proposed MER algorithm:

Original: [Equation]
Revised: [Equation]

Original: This can be achieved by using MERwhich maintains an experience replay  memory M with reservoir sampling and at each time step draws  k − 1 random samples from the buffer to be trained alongside the current example.
Revised: The MER algorithm: MER maintains an experience replay style memory M with reservoir sampling and at each time step draws s batches including k − 1 random samples from the buffer to be trained alongside the current example.

Original: Each of the k examples  is treated as its own Reptile batch of size 1.
Revised: Each of the k examples within each batch is treated as its own Reptile batch of size 1 with an inner loop Reptile meta-update after that batch is processed.

Revised: We then apply the Reptile meta-update again in an outer loop across the s batches.

Original:  In light of our ideal objective in equation 4, we can see that using a  batch size of 1 has an advantage over larger batches because it allows for the second derivative information conveyed to the algorithm to be ﬁne grained on the example level.
Revised: We provide further details for MER in algorithm 1. This procedure approximates the objective of equation 7 when β = 1 . Controlling the degree of regularization: In light of our ideal objective in equation 4, we can see that using a SGD batch size of 1 has an advantage over larger batches because it allows for the second derivative information conveyed to the algorithm to be ﬁne grained on the example level.

Original: Another reasonit makes sense to use sample level effective batches is because for a given number of samples drawn from the buffer we maximize k .
Revised: Another reason to use sample level effective batches is that for a given number of samples drawn from the buffer we maximize s from equation 6.

Original: In equation 7 the typical ofﬂine learning loss has a weighting proportional to k and the regularizer term to maximize transfer and minimize interference has a weighting proportional to αk ( k − 1) / 2 .
Revised: In equation 6, the typical ofﬂine learning loss has a weighting proportional to s and the regularizer term to maximize transfer and minimize interference has a weighting proportional to αs ( s − 1) / 2 .

Original: This implies that by maximizing k we can put more weight on the regularization term.
Revised: This implies that by maximizing the effective s we can put more weight on the regularization term.

Original: We demonstrate in our experiments that for a ﬁxed number of examples drawn from the buffer, we consistently achieve betterperformance by convertingit to a long list of individual samplesfor one update than we do by using proper batches as in the original Reptile paper targeting few shot learning. 
Revised: We found that for a ﬁxed number of examples drawn from M , we consistently performed better converting to a long list of individual samples than we did using proper batches as in (Nichol & Schulman, 2018) for few shot learning. Prioritizing current learning: To ensure strong regularization, we would like our number of batches processed in a Reptile update to be large – enough that experience replay alone would start to overﬁt to M .

Original: In the ﬁnal piece of the MER algorithm  we samples s separate batches fromthe buffer M that are processed sequentially and each interleaved with the current example we then apply the Reptile algorithm again in an outer loop across the s batches.
Revised: As such, we also need to make sure we provide enough priority to learning the current example, particularly because we may not store it in M . To achieve this in algorithm 1, we sample s separate batches from M that are processed sequentially and each interleaved with the current example.

Original: In the appendix we demonstrate that the terms differentiating this strategy from just constructing one big batch consisting of the same examples are small enough that they  approximate  the same objective.
Revised: In Appendix H we also outline two additional variants of MER with very similar properties in that they effectively approximate for the same objective.

Original: However, it is an effective means ofprioritizing the current example further when scaling to larger effective k values. We provide further details for MER in algorithm 1.
Revised: In one we choose one big batch of size sk − s memories and s copies of the current example (algorithm 5). In the other we choose one memory batch of size k − 1 with a special current item learning rate of sα (algorithm 6).

Original: As we explain in the appendix, we always set β = 1 to ensure we approximate the desired objective function.
Revised: Unique properties:

Original: It is important to note that while we use some of  the machinery of past work on meta-learning, the functional regularization on learning is totally different. Meta-learning applied to few shot learning aims to facilitate fast learning and large movements through the parameter space when adapting initial parameters to a new task by learning to encourage gradient agreement across minibatches.
Revised: In the end, our approach amounts to a quite easy to implement and computationally efﬁcient extension of SGD, which is applied to an experience replay buffer by leveraging the machinery of past work on optimization based meta-learning. However, the emergent regularization on learning is totally different than those previously considered. Past work on optimization based meta-learning has enabled fast learning on incoming data without considering past data.

Original: In contrast, for continual learning we are regularizing the objective to encourage the maximization ofknowledge transfer and the minimization of interference between the learning of any two examples.
Revised: Meanwhile, past work on experience replay only focused on stabilizing learning by approximating stationary conditions without altering model parameters to change the dynamics of transfer and interference.

Original:  EMPIRICAL E VALUATION FOR S UPERVISED C ONTINUAL L IFELONG L EARNING
Revised:  E VALUATION FOR S UPERVISED C ONTINUAL L IFELONG L EARNING

Original: To test the efﬁcacy of our Meta-Experience Replay (MER) approach we compare it to relevant baselines for continual learning of many supervised tasks  (see the appendix for in depth descriptions):
Revised: To test the efﬁcacy of MER we compare it to relevant baselines for continual learning of many supervised tasks from (Lopez-Paz & Ranzato, 2017) (see Appendix D for in-depth descriptions):

Original: • Online: represents online learning performance of a model trained straightforwardly one example at a time on the incoming non-stationary training data by simply applying SGD.
Revised: • Online: represents online learning performance of a model trained straightforwardly one example at a time on the incoming non-stationary training data by simply applying SGD.

Original: • Independent:1 is the performance of an independent predictor per task that can bepossibly initialized by cloning the last trained predictor if it leads to improved performance.
Revised: • Independent: an independent predictor per task with less hidden units proportional to the number of tasks. When useful, it can be initialized by cloning the last predictor.

Original: • Task Input:1 has the same architecture as Online, but with a dedicated input layer per task.
Revised: • Task Input: has the same architecture as Online, but with a dedicated input layer per task.

Original: • EWC: Elastic Weight Consolidation (EWC) (Kirkpatrick et al., 2017) is an algorithm that modiﬁes online learning where the loss is regularized to avoid catastrophic forgetting.
Revised: • EWC: Elastic Weight Consolidation (EWC) (Kirkpatrick et al., 2017) is an algorithm that modiﬁes online learning where the loss is regularized to avoid catastrophic forgetting.

Original: • GEM:
Revised: • GEM:

Original: Gradient Episodic Memory (GEM) (Lopez-Paz & Ranzato, 2017) is an approach for making efﬁcient use of episodic storage by following gradients on incoming examples to the maximum extent while altering them so that they do not interfere with past memories. 
Revised: Gradient Episodic Memory (GEM) (Lopez-Paz & Ranzato, 2017) is an approach for making efﬁcient use of episodic storage by following gradients on incoming examples to the maximum extent while altering them so that they do not interfere with past memories. An independent adhoc analysis is performed to alter each incoming gradient. In contrast to MER,

Original: In our experiments we follow (Lopez-Paz & Ranzato, 2017) and consider ﬁnal retained accuracy across all tasks after training sequentially on all tasks as our main metric for comparing approaches.
Revised: nothing generalizable is learned across examples about how to alter gradients. We follow (Lopez-Paz & Ranzato, 2017) and consider ﬁnal retained accuracy across all tasks after training sequentially on all tasks as our main metric for comparing approaches.

Original: Moving forward we will refer to this metric as retention .
Revised: Moving forward we will refer to this metric as retained accuracy (RA) .

Revised: In order to reveal more characteristics of the learning behavior, we also report the learning accuracy (LA) which is the average accuracy for each task directly after it is learned.

Revised: Additionally, we report the backward transfer and interference (BTI) as the average change in accuracy from when a task is learned to the end of training.

Revised: A highly negative BTI reﬂects catastrophic forgetting.

Revised: Forward transfer and interference (Lopez-Paz & Ranzato, 2017) is only applicable for one task we explore, so we provide details in Appendix K.

Original: Question 1 How does MER perform on supervised continual learning benchmarks?
Revised: Question 1 How does MER perform on supervised continual learning benchmarks?

Original: To address this question we consider two continual learning benchmarks from (Lopez-Paz & Ranzato, 2017).
Revised: To address this question we consider two continual learning benchmarks from (Lopez-Paz & Ranzato, 2017).

Original: MNIST Permutations is a variant of MNIST ﬁrst proposed in (Kirkpatrick et al., 2017) where each task is transformed by a ﬁxed permutation of the MNIST pixels.
Revised: MNIST Permutations is a variant of MNIST ﬁrst proposed in (Kirkpatrick et al., 2017) where each task is transformed by a ﬁxed permutation of the MNIST pixels.

Original: As such, the input distribution of each task is unrelated.
Revised: As such, the input distribution of each task is unrelated.

Original: MNIST Rotations is another variant of MNIST proposed in (Lopez-Paz & Ranzato, 2017) where each task contains digits rotated by a ﬁxed angle between 0 and 180 degrees.
Revised: MNIST Rotations is another variant of MNIST proposed in (Lopez-Paz & Ranzato, 2017) where each task contains digits rotated by a ﬁxed angle between 0 and 180 degrees.

Original: We follow the standard benchmark setting from (Lopez-Paz & Ranzato, 2017) using a modest memory buffer of size 5120 to learn 1000 sampled examples across each of 20 tasks.[Table]
Revised: We follow the standard benchmark setting from (Lopez-Paz & Ranzato, 2017) using a modest memory buffer of size 5120 to learn 1000 sampled examples across each of 20 tasks.

Original: [Table] Following conventions, we use a two layer MLP architecture for all models with 100 hidden units in each layer. We also model our hyperparameter search after (Lopez-Paz & Ranzato, 2017). We provide detailed information about the parameters we searched for and picked in the appendix.
Revised: We provide detailed information about our architectures and hyperparameters in Appendix J.

Original: In Table 1 we report results on these benchmarks in comparison to our baseline approaches.
Revised: In Table 1 we report results on these benchmarks in comparison to our baseline approaches.

Original: Clearly
Revised: Clearly

Original: GEM outperforms our other baselines [Table] but our approach adds signiﬁcant value over GEM in terms of ﬁnal retention accuracy on both benchmarks. 
Revised: GEM outperforms our other baselines, but our approach adds signiﬁcant value over GEM in terms of retained accuracy on both benchmarks. MER achieves this by striking a superior balance between transfer and interference with respect to the past and future data.

Revised: MER displays the best adaption to incoming tasks, while also providing very strong retention of knowledge when learning future tasks.

Original: EWC and using a task speciﬁc input layer both also lead tosigniﬁcant gains over standard online learning.
Revised: EWC and using a task speciﬁc input layer both also lead to gains over standard online learning in terms of retained accuracy.

Original: However, they are quite far below the performance of approaches that make usage of episodic storage.
Revised: However, they are quite far below the performance of approaches that make usage of episodic storage.

Original: Although EWC does notdirectly storeany examples,we should note that in storing the Fisher information for each task it accrues more incremental resources thanany of the episodic storage approaches.
Revised: While EWC does not store examples, in storing the Fisher information for each task it accrues more incremental resources than the episodic storage approaches.

Original: Question 

Revised: Question

Original: How do the performance gains from MER vary as a function of the buffer size?
Revised: How do the performance gains from MER vary as a function of the buffer size?

Original: Toreally make progress towards the greater goals of lifelong learning, we would like our algorithm to make the most use of even a modest buffer.
Revised: To make progress towards the greater goals of lifelong learning, we would like our algorithm to make the most use of even a modest buffer.

Original: This is because in extremely large scale settings it is  unrealistic to assume a system canfeasibly store a large percentage of previous examples in memory.
Revised: This is because in extremely large scale settings it is [Table] [Table] unrealistic to assume a system can store a large percentage of previous examples in memory.

Original: As such, we would like to compare MER to GEM, which is known to perform wellin this setting, in terms of how it can perform with an extremely small memory buffer.
Revised: As such, we would like to compare MER to GEM, which is known to perform well with an extremely small memory buffer (Lopez-Paz & Ranzato, 2017).

Original: We consider a buffer size of 500, that is over 10 times smaller than the standard setting on these benchmarks.
Revised: We consider a buffer size of 500, that is overtimes smaller than the standard setting on these benchmarks.

Original: Additionally, we also consider a buffer size of 200, matching the smallest setting explored in (LopezPaz & Ranzato, 2017).
Revised: Additionally, we also consider a buffer size of 200, matching the smallest setting explored in (Lopez-Paz & Ranzato, 2017).

Original: For these tasks this setting corresponds to an average storage of 1 example for each combination of task and class.
Revised: This setting corresponds to an average storage of 1 example for each combination of task and class.

Original: We report  resultsfor this setting in Table 2.
Revised: We report our results in Table 2.

Original: We can see that the beneﬁts ofusing MER over GEM grow as the buffersize becomes smaller.
Revised: The beneﬁts of MER seem to grow as the buffer becomes smaller.

Original: In the smallest setting, MER is providing more than a 10% boost in retention performance on both benchmarks.
Revised: In the smallest setting, MER provides more than a 10% boost in retained accuracy on both benchmarks.

Original: Question 3 How effective is MER at dealing with increasingly non-stationary settings?
Revised: Question 3 How effective is MER at dealing with increasingly non-stationary settings?

Original: Another larger goal of lifelong learning is to enable continual learning with only relatively few examples per task.
Revised: Another larger goal of lifelong learning is to enable continual learning with only relatively few examples per task.

Original: This setting is particularly difﬁcult because we have less data to characterize each class to learn from and our distribution is increasingly non-stationary over a ﬁxed amount of training.
Revised: This setting is particularly difﬁcult because we have less data to characterize each class to learn from and our distribution is increasingly non-stationary over a ﬁxed amount of training.

Original: We would like to explore how various models perform in this kind of setting.
Revised: We would like to explore how various models perform in this kind of setting.

Original: To do this we consider two new benchmarks.
Revised: To do this we consider two new benchmarks.

Original: Many Permutations is a variant of MNIST Permutations that has 5 times more tasks (100 total) and 5 times less training examples per task (200 each).Meanwhile
Revised: Many Permutations is a variant of MNIST Permutations that hastimes more tasks (100 total) and 5 times less training examples per task (200 each).

Original: [Table] in Omniglot we also explore the Omniglot (Lake et al., 2011) benchmark treating each of thealphabets to be a task.
Revised: Meanwhile we also explore the Omniglot (Lake et al., 2011) benchmark treating each of the 50 alphabets to be a task (see Appendix J for experimental details).

Original: Following multi-task task conventions 90% of the data is used for training and 10% is used for testing.
Revised: Following multi-task learning conventions, 90% of the data is used for training and 10% is used for testing (Yang & Hospedales, 2017).

Original: Overall there are 1623 different character classes.
Revised: Overall there are 1623 characters.

Original: We learn each class and task sequentially.
Revised: We learn each character and task sequentially with a task speciﬁc output layer.

Original: We follow (Vinyals et al., 2016) in scaling down the images to 28x28.

Original: Moreover, we also use a CNN that consists of a stack of 4 modules before a fully connected softmax layer where each module includes a 3x3 convolution with 64 ﬁlters, a Relu non-linearity and 2x2 max-pooling.

Original: We report continual learning results using these new datasets in Table 3.
Revised: We report continual learning results using these new datasets in Table 3.

Original: We can see in the case of the

Original:  Many Permutationsdataset that the effect of efﬁciently using episodic storage becomes even more pronounced when the setting becomes more non-stationary.
Revised: The effect on Many Permutations of efﬁciently using episodic storage becomes even more pronounced when the setting becomes more non-stationary.

Original: GEM and MER
Revised: GEM and MER

Original: both achieve nearly double the performance of EWC and online learning.
Revised: both achieve nearly double the performance of EWC and online learning.

Original: We also see that increasingly non-stationary settings lead to a larger performance gain for MER over GEM.
Revised: We also see that increasingly non-stationary settings lead to a larger performance gain for MER over GEM.

Original: Gains are quite signiﬁcant for Many Permutations and remarkable for Omniglot .
Revised: Gains are quite signiﬁcant for Many Permutations and remarkable for Omniglot .

Original: Omniglot is even more non-stationary including slightly fewer examples per task and MER nearly quadruples the performance of baseline techniques. 
Revised: Omniglot is even more non-stationary including slightly fewer examples per task and MER nearly quadruples the performance of baseline techniques. Considering the poor performance Model

Original: Considering the poor performance of online learning and EWC it is natural to question whether or not examples were learned in the ﬁrst place.
Revised: [Table] [Figure] of online learning and EWC it is natural to question whether or not examples were learned in the ﬁrst place.

Original: We experiment with using as many as 100 gradient descent steps per incoming example to ensure each example is learned when ﬁrst seen.
Revised: We experiment with using as many as 100 gradient descent steps per incoming example to ensure each example is learned when ﬁrst seen.

Original: However, do to the extremely non-stationary setting no  variant we tried surpassed 5.5% retained accuracy.
Revised: However, due to the extremely non-stationary setting no run of any variant we tried surpassed 5.5% retained accuracy.

Original: GEM also has major deﬁcits for learning on Omniglot that are resolved by MER.
Revised: GEM also has major deﬁcits for learning on Omniglot that are resolved by MER which achieves far better performance when it comes to quickly learning the current task.

Original: GEM maintains a buffer using a recent item based sampling strategy and thus can not deal with non-stationarity within the task nearly as well as reservoir sampling.
Revised: GEM maintains a buffer using a recent item based sampling strategy and thus can not deal with non-stationarity within the task nearly as well as reservoir sampling.

Original: Additionally, we found that the optimization based on the buffer was signiﬁcantly less effective and less reliable as the quadratic program fails for many hyperparameter values that lead to non-positive deﬁnite matrices.
Revised: Additionally, we found that the optimization based on the buffer was signiﬁcantly less effective and less reliable as the quadratic program fails for many hyperparameter values that lead to non-positive deﬁnite matrices.

Original: Unfortunately, we could not get 
Revised: Unfortunately, we could not get GEM to consistently converge on

Original: GEM to consistently converge on Omniglot for a memory size of 500, meanwhilewe see MER handles it well.
Revised: Omniglot for a memory size of 500 (signiﬁcantly less than the number of classes), meanwhile MER handles it well.

Original:  MER greatly outperforms GEM with an order of magnitude smaller buffer.
Revised: In fact, MER greatly outperforms GEM with an order of magnitude smaller buffer.

Revised: We provide additional details about our experiments on Omniglot in Figure 2.

Original: E MPIRICAL E VALUATION FOR C ONTINUAL R EINFORCEMENT L EARNING
Revised: We plot retained training accuracy, retained testing accuracy, and computation time for the entire training period using one CPU. We ﬁnd that MER strikes the best balance of computational efﬁciency and performance even when using algorithm 1 for MER which performs more computation than algorithm 6. The computation involved in the GEM update does not scale well to large CNN models like those that are popular for Omniglot. MER is far better able to ﬁt the training data than our baseline models while maintaining a computational efﬁciency closer to online update methods like EWC than GEM.

Original:  Question 4 Can MER improve a DQN with experience replay in continual reinforcement learning settings?
Revised: [Figure]  E VALUATION FOR C ONTINUAL R EINFORCEMENT L EARNING Question 4 Can MER improve a DQN with ER in continual reinforcement learning settings?

Original: We considered the evaluation of MER in a continual reinforcement learning setting where the environment is highly non-stationary.
Revised: We considered the evaluation of MER in a continual reinforcement learning setting where the environment is highly non-stationary.

Original: In order to produce these non-stationary environments in a controlled way suitable for our experimental purposes, we utilizeddifferent arcade games provided by Tasﬁ (2016).
Revised: In order to produce these non-stationary environments in a controlled way suitable for our experimental purposes, we utilized arcade games provided by Tasﬁ (2016).

Original: In our experiments we used Catcher and FlappyBird, two simple but interesting enough environments.
Revised: Speciﬁcally, we used Catcher and Flappy Bird, two simple but interesting enough environments (see Appendix M.1 for details).

Original: For the purposes of our explanation, we will call each set of ﬁxed gamedependent parameters a task 2 .
Revised: For the purposes of our explanation, we will call each set of ﬁxed game-dependent parameters a task 5 .

Original: The multi-task setting is then built by introducing changes in these parameters, resulting in non-stationarity across tasks.
Revised: The multi-task setting is then built by introducing changes in these parameters, resulting in non-stationarity across tasks.

Original: 3 As in our other experiments, each agent is  evaluated based on its retention of all tasks.Therefore, the reported performances provide a measurement of adaptation to the current task as well as of retention of knowledge acquired from other [Figure] Frame
Revised: Each agent is once again evaluated based on its performance over time on all tasks.

Original: M e a n sc o r e tasks. Our model uses a standard DQN setting originally developed for Atari (Mnih et al., 2015): a CNN that consist of a stack of 3 layers, the ﬁrst with 32 ﬁlters with kernel 8 by 8 and stride 4, a second layer with 64 ﬁlters with kernel 4 by 4 and stride 2, and a ﬁnal layer with 64 ﬁlters with kernel 3 by 3 and stride 1, followed by two fully connected layers. A ReLU non-linearity was applied after all the hidden layers. We limited the memory buffer size for our models to 50,000 transitions, which is roughly the same proportion of the total memories used in the benchmark setting four our supervised learning tasks.
Revised: Our model uses a standard DQN model, developed for Atari (Mnih et al., 2015).

Original: We illustrate the continual reinforcement learning scenario with these two games. In Catcher, the agent controls a segment that lies horizontally in the bottom of the screen, i.e. a basket, and can move right or left, or stay still. The goal is to move the basket to catch as many pellets, or fruits, as possible. Missing a fruit results in losing one of the three available lives.
Revised: See Appendix M.2 for implementation details.

Original: Fruits emerge one by one from the top of the screen, and have a descending velocity that is ﬁxed for each task. In this game, the different tasksare then obtained by incrementally increasing the fruit velocity a total of 6 times during training.In the case of the very popular game FlappyBird, the agent has to navigate a bird in an environment full of pipes by deciding whether to ﬂap or not ﬂap its wings. The pipes appear always in pairs, one from the bottom of the screen and one from the top of the screen, and have a gap that allows the bird to pass through them.
Revised: In Catcher, we then obtain different tasks by incrementally increasing the pellet velocity a total of 5 times during training.

Original: Flapping the wings results in the bird ascending, otherwise the bird descends to ground naturally.

Original: Both ascending and descending velocities are presets by the physics engine of the game. The goal is to pass through many pairs of pipes as possible without hitting a pipe, as this results in losing the game. The scoring scheme in this game awards a point each time a pipe is crossed. In our setting the different tasks are obtained by incrementally reducing the separation between upper and lower pipes a total of 6 times during training.
Revised: In Flappy Bird, the different tasks are obtained by incrementally reducing the separation between upper and lower pipes a total of 5 times during training.

Original: In Figure 3, we show the performance in Catcher when trained sequentially on 6 different tasks for 25,000 frames each to a maximum of 150k frames, evaluated at each point in time in all 6 tasks.
Revised: In Figure 4, we show the performance in Catcher when trained sequentially on 6 different tasks for 25k frames each to a maximum of 150k frames, evaluated at each point in time in all 6 tasks.

Original: Under these non-stationary conditions, a DQN using MER performs consistently better than the 
Revised: Under these nonstationary conditions, a DQN using MER performs consistently better than the standard DQN with an experience replay buffer.

Original: [Figure] regular DQN version that utilizes an experience replay buffer. Figure (3.1) shows the average score for the ﬁrst task, If we take as inspiration how humans perform, in the last stages of training we hope that a player that obtains good results in later tasks will also obtain good results in the ﬁrst tasks, insofar the ﬁrst tasks are subsumed in the latter ones.
Revised: If we take as inspiration how humans perform, in the last stages of training we hope that a player that obtains good results in later tasks will also obtain good results in the ﬁrst tasks, as the ﬁrst tasks are subsumed in the latter ones.

Original: For example, in Catcher,later tasks have the fruit move faster, and thus we expect to be able to do well in the ﬁrst task.
Revised: For example, in Catcher, the pellet moves faster in later tasks, and thus we expect to be able to do well on the ﬁrst task.

Original: However, DQN forgets signiﬁcantly  toperform the ﬁrst task, i.e., get slowly moving fruits.
Revised: However, DQN forgets signiﬁcantly how to get slowly moving pellets.

Original: Inmarked contrast, DQN-MER exhibits minimal or no forgettingfor the ﬁrst set of episodes after being trained in the rest of the tasks.
Revised: In contrast, DQN-MER exhibits minimal or no forgetting after training on the rest of the tasks.

Original: This behavior is intuitive in the sense previously exposed that we would expectforward transfer to happen naturally in this setting, as it seems to be the case with human players.
Revised: This behavior is intuitive because we would expect transfer to happen naturally in this setting.

Original: Similar behavior appears in Flappy Bird.
Revised: We see similar behavior for Flappy Bird.

Original: DQN-MER becomes a Platinum player for the ﬁrst task environment during the period in which is learning the third task, a more difﬁcult environment in which the pipe gap is noticeably smallerthan in the ﬁrst task (see Appendix E.2). Then, DQN-MER keeps this level forward for  the ﬁrst and second task environments.
Revised: DQNMER becomes a Platinum player on the ﬁrst task when it is learning the third task. This is a more difﬁcult environment in which the pipe gap is noticeably smaller (see Appendix M.4). DQN-MER exhibits the kind of learning patterns expected from humans for these games, while a standard DQN struggles to generalize as the game changes and to retain knowledge over time.

Original:  F URTHER A NALYSIS OF THE A PPROACH
Revised:  F URTHER A NALYSIS OF THE A PPROACH

Original: In this section we would like to dive deeper into how MER works.
Revised: In this section we would like to dive deeper into how MER works.

Original: To do so we run additional detailed experiments across our three MNIST based continual learning benchmarks. 
Revised: To do so we run additional detailed experiments across our three MNIST based continual learning benchmarks. [Table]

Original: Question 5 Does MER lead to a shift in the distribution of gradient dot products?
Revised: Question 5 Does MER lead to a shift in the distribution of gradient dot products?

Original: We would like to directly verify that MER achieves our motivation in equation 7 and results in signiﬁcant changes in the distribution of gradient dot products between new incoming examples and past examples over the course of learning when compared to experience replay (ER).
Revised: We would like to directly verify that MER achieves our motivation in equation 7 and results in signiﬁcant changes in the distribution of gradient dot products between new incoming examples and past examples over the course of learning when compared to experience replay (ER).

Original: For these experiments, we maintain a history of all examples seen that is totally separate from our notion of memory buffers that only include a partial history of examples.
Revised: For these experiments, we maintain a history of all examples seen that is totally separate from our notion of memory buffers that only include a partial history of examples.

Original: Every time we receive a new example we use the current model to extract a gradient direction and we also randomly sample ﬁve examples from the previous history.
Revised: Every time we receive a new example we use the current model to extract a gradient direction and we also randomly sample ﬁve examples from the previous history.

Original: We save the dot products of the incoming example gradient with these ﬁve past example gradients and consider the mean of the distribution of dot products seen over the course of learning for each model.
Revised: We save the dot products of the incoming example gradient with these ﬁve past example gradients and consider the mean of the distribution of dot products seen over the course of learning for each model.

Original: We run this experiment on the best hyperparamater setting for both our ER model and our MER model with one batch per example for fair comparison.
Revised: We run this experiment on the best hyperparamater setting for both our ER model and our MER model with one batch per example for fair comparison.

Original: Each model is evaluated ﬁve times over the course of learning.
Revised: Each model is evaluated ﬁve times over the course of learning.

Original: We report mean and standard deviations[Table] of the mean gradient dot product across runs in Table 4.
Revised: We report mean and standard deviations of the mean gradient dot product across runs in Table 4.

Original: We can thus verify that a very signiﬁcant and reproducible difference in the mean gradient encountered is seen for MER in comparison to ER alone.
Revised: We can thus verify that a very signiﬁcant and reproducible difference in the mean gradient encountered is seen for MER in comparison to ER alone.

Original: This difference alters the learning process making incoming examples on average result in slight transfer rather than signiﬁcant interference.
Revised: This difference alters the learning process making incoming examples on average result in slight transfer rather than signiﬁcant interference.

Original: This analysis conﬁrms the desired effect of the objective function in equation 7.
Revised: This analysis conﬁrms the desired effect of the objective function in equation 7.

Revised: For these tasks there are enough similarities that our meta-learning generalizes very well into the future.

Revised: We should also expect it to perform well in the case of drastic domain shifts like other meta-learning algorithms driven by SGD alone (Finn & Levine, 2017).

Original: Question 6 What components of MER are most important?
Revised: Question 6 What components of MER are most important?

Original: We would like to further analyze ourproposed MER model to understand what components add the most value and when.
Revised: We would like to further analyze our MER model to understand what components add the most value and when.

Original: More speciﬁcally we would like to understand how powerful our  variant of experience replay described in section 3.2 is on its own and how much is added by adding metalearning to experience replay both within a batch and across multiple batches per example.
Revised: We want to understand how powerful our proposed variant of ER is on its own and how much is added by adding meta-learning to ER.

Original: In the appendix we provide detailed results considering ablated baselines for our experiments on the MNIST lifelong learning benchmarks.
Revised: In Appendix L we provide detailed results considering ablated baselines for our experiments on the MNIST lifelong learning benchmarks.

Original: We consistently see that our version of experience replay provides gains over GEM on its own.
Revised: Our version of ER consistently provides gains over GEM on its own, but the techniques perform very comparably when we also maintain GEM’s buffer with reservoir sampling our use ER with a GEM style buffer. Additionally, we see that adding meta-learning to ER consistently results in performance gains.

Original: Clearly the value  of optimizing over an approximation of  the stationary distribution is hard to beat in these problem settings.
Revised: In fact, meta-learning appears to provide increasing value for smaller buffers. We would also like to compare the variants of MER proposed in algorithms 1, 5, and 6. Conceptually algorithms 1 and 6 represent different mechanisms of increasing the importance of the current example in algorithm 5.

Original: However, we see that both performing meta-learning within the batch and across multiple batches per example consistently create additional value in our experiments. Meta-learning appears to provide increasing value as the buffer size becomes smaller.
Revised: We ﬁnd that all variants of MER result in signiﬁcant improvements on ER in all settings. Meanwhile, the variants that increase the importance of the current example see a further improvement in performance, performing quite comparably to each other. Overall, in our

Original: C ONCLUSION
Revised: MNIST experiments algorithm 6 displays the best tradeoff of computational efﬁciency and performance. Finally, we conducted experiments demonstrating that adaptive optimizers like Adam and RMSProp can not account for the gap between ER and MER. Particularly for smaller buffer sizes, these approaches overﬁt more on the buffer and actually hurt generalization in comparison to SGD.

Revised:  C ONCLUSION

Original: In this paper we have cast a new perspective on the problem of continual learning in terms of a fundamental trade-off between transfer and interference.
Revised: In this paper we have cast a new perspective on the problem of continual learning in terms of a fundamental trade-off between transfer and interference.

Original: Exploiting this perspective, we have in turn developed a new algorithm Meta-Experience Replay (MER) that is well suited for application to general purpose continual learning problems.
Revised: Exploiting this perspective, we have in turn developed a new algorithm Meta-Experience Replay (MER) that is well suited for application to general purpose continual learning problems.

Original: We have demonstrated that MER regularizes the objective of experience replay so that gradients on incoming examples are more likely to have transfer and less likely to have interference with respect to past examples.
Revised: We have demonstrated that MER regularizes the objective of experience replay so that gradients on incoming examples are more likely to have transfer and less likely to have interference with respect to past examples.

Original: The result is a general purpose solution to continual learning problems that outperforms strong baselines for both supervised continual learning benchmarks and continual learning in non-stationary reinforcement learning environments.
Revised: The result is a general purpose solution to continual learning problems that outperforms strong baselines for both supervised continual learning benchmarks and continual learning in non-stationary reinforcement learning environments.

Original: In this paper we argue that techniques for continual learning have been largely driven by different conceptualizations of the fundamental problem encountered by neural networks and as such we hope that the transfer-interference trade-off can be a useful problem view for future work to exploit with 
Revised: Techniques for continual learning have been largely driven by different conceptualizations of the fundamental problem encountered by neural networks. We hope that the transfer-interference tradeoff can be a useful problem view for future work to exploit with MER as a ﬁrst successful example. A C ONTINUAL L EARNING P ROBLEM F ORMULATION

Original: MER as a ﬁrst successful example.
Revised: In the classical ofﬂine supervised learning setting, a learning agent is given a ﬁxed training data set D = { ( x i , y i ) } ni =1 of n samples, each containing an input feature vector x i ∈ X associated with the corresponding output (target, or label) y i ∈ Y ; a common assumption is that the training samples are i.i.d. samples drawn from the same unknown joint probability distribution P ( x , y ) . The learning task is often formulated as a function approximation problem, i.e. ﬁnding a function, or model, f θ ( x ) :

Original: A F URTHER D ESCRIPTIONS AND C OMPARISONS WITH B ASELINE A LGORITHMS
Revised: X → Y from a given class of models (e.g., neural networks, decision trees, linear functions, etc.) where θ are the parameters estimated from data. Given a loss function L ( f θ ( x ) , y ) , the parameter estimation is formulated as an empirical risk minimization problem: [Equation]

Revised: On the contrary, the online learning setting does not assume a ﬁxed training dataset but rather a stream of data samples, where unlabeled feature vectors arrive one at a time, or in small minibatches, and the learner must assign labels to those inputs, receive the correct labels, and update the model accordingly, in iterative fashion.

Revised: While classical online learning assumes i.i.d.

Revised: samples, continual or lifelong learning does not make such an assumption, and requires a learning agent to handle non-stationary data streams.

Revised: In this work, we deﬁne continual learning as online learning from a non-stationary input data stream, with a speciﬁc type of non-stationarity as deﬁned below.

Revised: Namely, we follow a commonly used setting to deﬁne non-stationary conditions for continual learning, dubbed locally i.i.d by (Lopez-Paz & Ranzato, 2017), where the agent learns over a sequence of separate stationary distributions one after another.

Revised: We call the individual stationary distributions tasks , where each task t k is an online supervised learning problem associated with its own data probability distribution P k ( x , y ) .

Revised: Namely, we are given a (potentially inﬁnite) sequence

Revised: [Equation]

Revised: While many continual learning methods assume the task descriptors t k are available to a learner, we are interested in developing approaches which do not have to rely on such information and can learn continuously without explicit announcement of the task change.

Revised: Borrowing terminology from (Chaudhry et al., 2018), we explore the single-headed setting in most of our experiments, which keeps learning a common function f θ across changing tasks.

Revised: In contrast, multi-headed learning, which we consider for our Omniglot experiments, involves a separate ﬁnal classiﬁcation layer for each task.

Revised: This makes more sense in case of Omniglot dataset, where the number of classes for each task varies considerably from task to task.

Revised: We should also note that for Omniglot we consider a setting that is locally i.i.d.

Revised: at the class level rather than the task level.

Revised: B R ELATION TO P AST W ORK

Revised: With regard to the continual learning setting speciﬁcally, other recent work has explored similar operational measures of transfer and interference.

Revised: For example, the notions of Forward Transfer and Backward Transfer were explored in (Lopez-Paz & Ranzato, 2017).

Revised: However, the approach of that work, GEM, was primarily concerned with solving the classic stability-plasticity dilemma (Carpenter & Grossberg, 1987) at a speciﬁc instance of time.

Revised: Adjustments to gradients on the current data are made in an adhoc manner solving a quadratic program separately for each example.

Revised: In our work we try to learn a generalizeable theory about weight sharing that can learn to inﬂuence the distribution of gradients not just in the past and present, but in the future as well.

Revised: Additionally, in (Chaudhry et al., 2018) similar ideas were explored with operational measures of intransigenc e (the inability to learn new data) and forgetting (the loss of previous performance).

Revised: These measures are also intimately related to the stability-plasticity dilemma as intransigence is high when plasticity is low and forgetting is high when stability is low.

Revised: The major distinction in the transfer-interference tradeoff proposed in this work is that we aim to learn the optimal weight sharing scheme to optimize for the stability-plasticity dilemma with the hope that our learning about weight sharing will improve the stability and efﬁcacy of learning on unseen data as well.

Revised: With regard to the problem of weight-sharing in neural networks more generally, a host of different strategies have been proposed in the past to deal with the problems of catastrophic forgetting and/or the stability-plasticity dilemma (for review, see (French, 1999)).

Revised: For example, one strategy for alleviating catstrophic forgetting is to make distributed representations less distibuted – or semi-distributed (French, 1991) – for the case of past learning.

Revised: French (1991) k-node activation sharpening is a prominent example.

Revised: A second strategy known as dual network models (McClelland et al., 1995; Ans & Rousset, 1997) is based on the neurobiological ﬁnding that both hippocampal and cortical circuits contributed differentially to memory.

Revised: The cortical circuits are highly distributed with overlapping representations suitable for task generalization, while the more sparse hippocampal representations tend to be non-overlapping.

Revised: The existence of dual circuits provides an extra degree of freedom for balancing the dual constriants of stability and plasticity.

Revised: (In a similar spirit, models have been proposed that have two classes of weights operating on two different timescales (Hinton & Plaut, 1987).)

Revised: A third strategy also motivated by neurobiological considerations is the use of latent synaptic dynamics (Fusi et al., 2005; Lahiri & Ganguli, 2013).

Revised: Here the basic idea is that synaptic strength is determined by a multiple of variables, including latent ones not easily observed, operating at different timsescales such that their net effect is to provide the system with additional degrees-of-freedom to store past experience without interfering with current learning.

Revised: A fourth strategy is the use of feedback mechanisms to stabilize representations (Carpenter & Grossberg, 1987; Murre, 1992).

Revised: In this class of models, a previously experienced memory will trigger top down feedback that prevents plasticity, while novel stimuli that experience no such feedback trigger plasticity.

Revised: All of these approaches have their own strengths and weaknesses with respect to the stability-plasticity dilemma and, by extension, the transfer-interfererence tradeoff we propose.

Revised: Another relevant work is the POWERPLAY framework (Schmidhuber, 2004; 2013) which is a method for asymptotically optimal curriculum learning that by deﬁnition cannot forget previously learned skills.

Revised: POWERPLAY also uses environment-independent replay of behavioral traces to avoid forgetting previous skills.

Revised: However, POWERPLAY is orthogonal to our work as we consider a different setting where the agent cannot directly control the new tasks that will be encountered in the environment and thus must instead learn to adapt and react to non-stationarity conditions.

Revised: In contrast to past work on meta-learning for few shot learning (Santoro et al., 2016; Vinyals et al., 2016; Ravi & Larochelle, 2016; Finn et al., 2017) and reinforcement learning across successive tasks (Al-Shedivat et al., 2018), we are not only trying to improve the speed of learning on new data, but also trying to do it in a way that preserves knowledge of past data and generalizes to future data.

Revised: While past work has considered learning to inﬂuence gradient angles, so that there is more alignment and thus faster learning within a task, we focus on a setting where we would like to inﬂuence gradient angles from all tasks at all points in time.

Revised: As our model aims to inﬂuence the dynamics of weight sharing, it bears conceptual similarity to mixtures of experts (Jacobs et al., 1991) style models for lifelong and multi-task learning (Misra et al., 2016; Riemer et al., 2016b; Aljundi et al., 2017; Fernando et al., 2017;

Revised: Shazeer et al., 2017;

Revised: Rosenbaum et al., 2018).

Revised: MER implicitly effects the dynamics of weight sharing, but it is possible that combining it with mixtures of experts models could further amplify the ability for the model to control these dynamics.

Revised: This is potentially an interesting avenue for future work.

Revised: The Options framework has also been considered as a solution to a similar continual RL setting to the one we explore (Mankowitz et al., 2018).

Revised: Options formalize the notion of temporally abstraction actions in RL.

Revised: Interestingly, generic architectures designed for shallow (Bacon et al., 2017) or deep (Riemer et al., 2018) hierarchies of options in essence learn very complex patterns of weight sharing over time.

Revised: The option hierarchies constitute an explicit mechanism of controlling the extent of weight sharing for continual learning, allowing for orthogonalization of weights relating to different skills.

Revised: In contrast, our work explores a method of implicitly optimizing weight sharing for continual learning that improves the efﬁcacy of experience replay.

Revised: MER should be simple to implement in concert with options based methods and combining the two is an interesting direction for future work.

Revised: C T HE C ONNECTION B ETWEEN W EIGHT S HARING AND THE T RANSFER -I NTERFERENCE T RADE - OFF

Revised: In this section we would like to generalize our interpretation of a large set of different weight sharing schemes including (Riemer et al., 2015; Bengio et al., 2015; Rosenbaum et al., 2018; Serr`a et al., 2018) and how the concept of weight sharing impacts the dynamics of transfer (equation 1) and interference (equation 2).

Revised: We will assume that we have a total parameter space θ that can be used by our network at any point in time.

Revised: However, it is not a requirement that all parameters are actually used at all points in time.

Revised: So, we can consider two speciﬁc instances in time.

Revised: One where we receive data point ( x 1 , y 1 ) and leverage parameters θ 1 .

Revised: Then, at the other instance in time, we receive data point ( x 2 , y 2 ) and leverage parameters θ 2 .

Revised: θ 1 and θ 2 are both subsets of θ and critically the overlap between these subsets inﬂuences the possible extent of transfer and interference when training on either data point.

Revised: First let us consider two extremes.

Revised: In the ﬁrst extreme imagine θ 1 and θ 2 are entirely nonoverlapping.

Revised: As such ∂L ( x 1 ,y 1 ) ∂θ ·

Revised: [Equation]

Revised: [Equation]

Revised: = 0 .

Revised: On the positive side, this means that our solution has no potential for interference between the examples.

Revised: On the other hand, there is no potential for transfer either.

Revised: On the other extreme, we can imagine that θ 1 = θ 2 .

Revised: In this case, the potential for both transfer and interference is maximized as gradients with respect to every parameter have the possibility of a non-zero dot product with each other.

Revised: From this discussion it is clear that both the extreme of full weight sharing and the extreme of no weight sharing have value depending on the relationship between data points.

Revised: What we would really like for continual learning is to have a system that learns when to share weights and when not to on its own.

Revised: To the extent that our learning about weight sharing generalizes, this should allow us to ﬁnd an optimal solution to the transfer-interference trade-off.

Original: Independent: originally reported in (Lopez-Paz & Ranzato, 2017) is the performance of an independent predictor per task which has the same architecture but with less hidden units proportional to the number of tasks.
Revised: Independent: originally reported in (Lopez-Paz & Ranzato, 2017) is the performance of an independent predictor per task which has the same architecture but with less hidden units proportional to the number of tasks.

Original: The independent predictor can be initialized randomly or clone the last trained predictor depending on what leads to better performance.
Revised: The independent predictor can be initialized randomly or clone the last trained predictor depending on what leads to better performance.

Original: EWC: Elastic Weight Consolidation (EWC) (Kirkpatrick et al., 2017) is an algorithm that modiﬁes online learning where the loss is regularized to avoid catastrophic forgetting by considering the importance of parameters in the model as measured by their ﬁsher information.
Revised: EWC: Elastic Weight Consolidation (EWC ) (Kirkpatrick et al., 2017) is an algorithm that modiﬁes online learning where the loss is regularized to avoid catastrophic forgetting by considering the importance of parameters in the model as measured by their ﬁsher information.

Original: EWC follows the catastrophic forgetting view of the continual learning problem by promoting less sharing of parameters for new learning that were deemed to be important for performance on old memories .
Revised: EWC follows the catastrophic forgetting view of the continual learning problem by promoting less sharing of parameters for new learning that were deemed to be important for performance on old memories .

Original: We utilize the code provided by (Lopez-Paz & Ranzato, 2017) in our experiments.
Revised: We utilize the code provided by (Lopez-Paz & Ranzato, 2017) in our experiments.

Original: The only difference in our setting is that we provide the model one example at a time to test true continual learning rather than providing a batch of 10 examples at a time.
Revised: The only difference in our setting is that we provide the model one example at a time to test true continual learning rather than providing a batch of 10 examples at a time.

Original: GEM:
Revised: GEM:

Original: Gradient Episodic Memory (GEM) (Lopez-Paz & Ranzato, 2017) is an algorithm meant to enhance the effectiveness of episodic storage based continual learning techniques by allowing the model to adapt to incoming examples using SGD as long as the gradients do not interfere with examples from each task stored in a memory buffer.
Revised: Gradient Episodic Memory (GEM) (Lopez-Paz & Ranzato, 2017) is an algorithm meant to enhance the effectiveness of episodic storage based continual learning techniques by allowing the model to adapt to incoming examples using SGD as long as the gradients do not interfere with examples from each task stored in a memory buffer.

Original: If gradients interfere leading to a decrease in the performance of a past task, a quadratic program is used to solve for the closest gradient to the original that does not have negative gradient dot products with the aggregate memories from any previous tasks.
Revised: If gradients interfere leading to a decrease in the performance of a past task, a quadratic program is used to solve for the closest gradient to the original that does not have negative gradient dot products with the aggregate memories from any previous tasks.

Original: GEM is known to achieve superior performance in comparison to other recently proposed techniques that use episodic storage like (Rebufﬁ et al., 2017), making superior use of small memory buffer sizes.
Revised: GEM is known to achieve superior performance in comparison to other recently proposed techniques that use episodic storage like (Rebufﬁ et al., 2017), making superior use of small memory buffer sizes.

Original: GEM follows similar motivation to our approach in that it also considers the intelligent use of gradient dot product information to improve the use case of supervised continual learning.
Revised: GEM follows similar motivation to our approach in that it also considers the intelligent use of gradient dot product information to improve the use case of supervised continual learning.

Original: As a result, it a very strong and interesting baseline to compare with our approach.
Revised: As a result, it a very strong and interesting baseline to compare with our approach.

Original: We modify the original code and benchmarks provided by (Lopez-Paz & Ranzato, 2017).
Revised: We modify the original code and benchmarks provided by (Lopez-Paz & Ranzato, 2017).

Original: Once again the only difference in our setting is that we provide the model one example at a time to test true continual learning rather than providing a batch of 10 examples at a time.
Revised: Once again the only difference in our setting is that we provide the model one example at a time to test true continual learning rather than providing a batch of 10 examples at a time.

Original: We can consider the GEM algorithm as tailored to the stability-plasticity dilemma conceptualization of continual learning in that it looks to preserve performance on past tasks while allowing for maximal plasticity to the new task.
Revised: We can consider the GEM algorithm as tailored to the stability-plasticity dilemma conceptualization of continual learning in that it looks to preserve performance on past tasks while allowing for maximal plasticity to the new task.

Original: To achieve this, GEM (Lopez-Paz & Ranzato, 2017) solves a quadratic program to ﬁnd an approximate gradient g new that closely matches ∂L ( x new ,y new )
Revised: To achieve this, GEM (Lopez-Paz & Ranzato, 2017) solves a quadratic program to ﬁnd an approximate gradient g new that closely matches ∂L [Equation] new [Equation]

Original:  ∂θ while ensuring that the following constraint holds:
Revised: new ) ∂θ while ensuring that the following constraint holds:

Original: [Equation]
Revised: [Equation]

Revised: E R EPTILE A LGORITHM

Revised: We detail the standard Reptile algorithm from (Nichol & Schulman, 2018) in algorithm 2.

Revised: The sample function randomly samples s batches of size k from dataset D .

Revised: The SGD function applies min-batch stochastic gradient descent over a batch of data given a set of current parameters and learning rate.

Revised: procedure T RAIN ( D, θ, α, β, s, k ) while not done do // Draw batches from data:

Revised: B 1 , ..., B s ← sample ( D, s, k ) θ 0 ← θ for i = 1 , ..., s do θ i ← SGD ( B i , θ i − 1 , α ) end for //

Revised: Reptile meta-update: θ ← θ 0 + β ( θ s − θ 0 ) end while return θ end procedure

Revised: F D ETAILS ON R ESERVOIR S AMPLING

Revised: Throughout this paper we refer to updates to our memory M as M ← M ∪ { ( x, y ) } .

Revised: We would like to now provide details on how we update our memory buffer using reservoir sampling as outlined in (Vitter, 1985) (algorithm 3).

Revised: Reservoir sampling solves the problem of keeping some limited number

Revised: M of N total items seen before with equal probability MN when you don’t know what number N will be in advance.

Revised: The randomInteger function randomly draws an integer inclusively between the provided minimum and maximum values.

Revised: Algorithm procedure R ESERVOIR ( M, N, x, y )

Revised: if M > N then

Revised: M [ N ] ← ( x, y ) else j = randomInteger ( min = 0 , max = N ) if j < M then

Revised: M [ j ] ← ( x, y ) end if end if return M end procedure

Revised: G E XPERIENCE R EPLAY A LGORITHM

Revised: We detail the our variant of the experience replay in algorithm 4.

Revised: This procedure closely follows recent enhancements discussed in (Zhang & Sutton, 2017; Riemer et al., 2017b;a)

Revised: The sample function randomly samples k − 1 examples from the memory buffer M and interleaves them with the current example to form a single size k batch.

Revised: The SGD function applies min-batch stochastic gradient descent over a batch of data given a set of current parameters and learning rate.

Revised: procedure T RAIN ( D, θ, α, k )

Revised: M ← {} for t = 1 , ..., T do for ( x, y ) in D t do // Draw batch from buffer:

Revised: B ← sample ( x, y, k, M ) // Update parameters with mini-batch SGD: θ ← SGD ( B, θ, α ) //

Revised: Reservoir sampling memory update:

Revised: M ← M ∪ { ( x, y ) } (algorithm 3) end for end for return θ, M end procedure

Revised: H T HE V ARIANTS OF MER

Revised: We detail two additional variants of MER (algorithm 1) in algorithms 5 and 6.

Revised: The sample function takes on a slightly different meaning in each variant of the algorithm.

Revised: In algorithm 1 sample is used to produce s batches consisting of k − 1 random examples from the memory buffer and the current example.

Revised: In algorithm 5 sample is used to produce one batch consisting of sk − s examples from the memory buffer and s copies of the current example.

Revised: In algorithm 6 sample is used to produce one batch consisting of k − 1 examples from the memory buffer.

Revised: In contrast, the SGD function carries a common meaning across algorithms, applying stochastic gradient descent over a particular input and output given a set of current parameters and learning rate.

Revised: Algorithm

Revised: T

Revised: ( D, θ, α, γ, sk )

Revised: M ← {} for t = 1 , ..., T do for ( x, y ) in D t do // Draw batch from buffer:

Revised: B ← sample ( x, y, s, k, M ) θ 0 ← θ for i = 1 , ..., sk do x c , y c ← B i [ j ] θ i ← SGD ( x c , y c , θ i − 1 , α ) end for //

Revised: Reptile meta-update: θ ← θ 0 + γ ( θ sk − θ 0 ) //

Revised: Reservoir sampling memory procedure T RAIN ( D, θ, α, γ, s, k )

Revised: M ← {} for t = 1 , ..., T do for ( x, y ) in D t do // Draw batch from buffer:

Revised: B ← sample ( k − 1 , M ) θ 0 ← θ //

Revised: SGD on individual samples from batch: for i = 1 , ..., k − 1 do x c , y c ← B i [ j ] θ i ← SGD ( x c , y c , θ i − 1 , α ) end for // High learning rate SGD on current example: θ k ← SGD ( x, y, θ k − 1 , sα ) //

Revised: Reptile meta-update: θ ← θ 0 + γ ( θ k − θ 0 ) //

Revised: Reservoir sampling memory update:

Revised: M ← M ∪ { ( x, y ) } (algorithm 3) end for end for return θ, M end procedure

Original: B D ERIVING THE E FFECTIVE O BJECTIVE OF MER
Revised: I D ERIVING THE E FFECTIVE O BJECTIVE OF MER

Original: We would like to derive what objectiveour proposed Meta-Experience Replay algorithm (1) approximates.
Revised: We would like to derive what objective Meta-Experience Replay (algorithm 1) approximates and show that it is approximately the same objective from algorithms 5 and 6.

Original: We follow conventions from (Nichol & Schulman, 2018) and ﬁrst demonstrate what happens to the effective gradients computed by the algorithm in the most trivial case.
Revised: We follow conventions from (Nichol & Schulman, 2018) and ﬁrst demonstrate what happens to the effective gradients computed by the algorithm in the most trivial case.

Original: As in (Nichol & Schulman, 2018), this allows us to extrapolate an effective gradient that is a function of the number of steps taken.
Revised: As in (Nichol & Schulman, 2018), this allows us to extrapolate an effective gradient that is a function of the number of steps taken.

Original: We can then consider the effective loss function that results in this gradient.
Revised: We can then consider the effective loss function that results in this gradient.

Original: Before we begin, let us deﬁne the following terms from (Nichol & Schulman, 2018): 
Revised: Before we begin, let us deﬁne the following terms from (Nichol & Schulman, 2018): [Equation]

Original: [Equation] [Equation] 
Revised: [Equation] [Equation] [Equation]

Original: (Hessian evaluated at point i with respect to parameters j) 
Revised: (gradient evaluated at point i with respect to parameters j) [Equation] point

Original: [Equation]
Revised: [Equation]

Revised: respect

Original: [Equation]
Revised: [Equation]

Original:  In (Nichol & Schulman, 2018) they consider the effective gradient across one loop of reptile with size k = 2 .
Revised: parameters [Equation] In (Nichol & Schulman, 2018) they consider the effective gradient across one loop of reptile with size k = 2 .

Original: As we have both an outer loop of Reptile applied across batches and an inner loop applied within the batch, we start with a setting where the number of batches s = 2 and the number of examples per batch k = 2 .
Revised: As we have both an outer loop of Reptile applied across batches and an inner loop applied within the batch to consider, we start with a setting where the number of batches s = 2 and the number of examples per batch k = 2 .

Original: Let’s recall from the original paper that the gradients of Reptile with k = 2 was:
Revised: Let’s recall from the original paper that the gradients of Reptile with k = 2 was:

Original: [Equation] 
Revised: [Equation] [Equation]

Original: So, we can also consider the gradients of Reptile if we had 4 examples in one big batch  as opposed to 2 batches of 2 examples:
Revised: So, we can also consider the gradients of Reptile if we had 4 examples in one big batch (algorithm 5) as opposed to 2 batches of 2 examples:

Original: [Equation]
Revised: [Equation]

Original: Now we can consider the case for MER where we deﬁne the parameter values as follows extending algorithm 1:
Revised: Now we can consider the case for MER where we deﬁne the parameter values as follows extending algorithm 1 where A stands for across batches and W stands for within batches:

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: g MER the gradient of Meta-Experience Replay can thus be deﬁned analogously to the gradient of
Revised: g MER the gradient of Meta-Experience Replay can thus be deﬁned analogously to the gradient of

Original: Reptile as:
Revised: Reptile as:

Original: [Equation]
Revised: [Equation]

Original: By simply applying Reptile from equation 15 we can derive the value of the parameters θ A 1 after updating with Reptile within the ﬁrst batch in terms of the original parameters θ 0 :
Revised: By simply applying Reptile from equation 15 we can derive the value of the parameters θ A 1 after updating with Reptile within the ﬁrst batch in terms of the original parameters θ 0 :

Original: [Equation] 
Revised: [Equation] [Equation]

Original: By subbing equation 26 into equation 23 we can see that:
Revised: By subbing equation 26 into equation 23 we can see that:

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: We can express g 10 in terms of the initial point, by considering a Taylor expansion following the
Revised: We can express g 10 in terms of the initial point, by considering a Taylor expansion following the

Original: Reptile paper:
Revised: Reptile paper:

Original: [Equation]
Revised: [Equation]

Original: Then substituting in for θ W 10 we express g 10 in terms of θ 0 :
Revised: Then substituting in for θ W 10 we express g 10 in terms of θ 0 :

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: We can then rewrite g 11 by taking a Taylor expansions with respect to θ W 10 :
Revised: We can then rewrite g 11 by taking a Taylor expansions with respect to θ W 10 :

Original: [Equation]
Revised: [Equation]

Original: Taking another Taylor expansion we ﬁnd that we can transform our expression for the Hessian:
Revised: Taking another Taylor expansion we ﬁnd that we can transform our expression for the Hessian:

Original: [Equation] 
Revised: [Equation] [Equation]

Original: We can analogously also transform our expression our expression for g 1011 :
Revised: We can analogously also transform our expression our expression for g 1011 :

Original: [Equation]
Revised: [Equation]

Original: Substituting for θ W 10 in terms of θ
Revised: Substituting for θ W 10 in terms of θ

Original: [Equation]
Revised: [Equation]

Original: We then substitute equation 31, equation 33, and equation 29 into equation 34:[Equation] [Equation] Finally
Revised: We then substitute equation 31, equation 33, and equation 29 into equation 34:

Original: [Equation]
Revised: [Equation]

Original:  we have all of the terms we need to express θ A 

Revised: Finally, we have all of the terms we need to express θ A

Original: and we can then derive an expression for the
Revised: and we can then derive an expression for the

Original: MER gradient g MER :
Revised: MER gradient g MER :

Original: [Equation]
Revised: [Equation]

Original: This equation is quite interesting and very similar to equation 16.
Revised: This equation is quite interesting and very similar to equation 16.

Original: As we would like to approximate the same objective, we  remove one hyperparameter from our model by setting β = 1 .
Revised: As we would like to approximate the same objective, we can remove one hyperparameter from our model by setting β = 1 .

Original: This yields:
Revised: This yields:

Original: [Equation] 
Revised: [Equation] [Equation]

Original: Indeed, with β set to equal 1, we have shown that the gradient of MER is the same as one loop of Reptile with a number of steps equal to the total number of examples in all batches of MER.
Revised: Indeed, with β set to equal 1, we have shown that the gradient of MER is the same as one loop of Reptile with a number of steps equal to the total number of examples in all batches of MER (algorithm 5) if the current example is mixed in with the same proportion.

Revised: If we include in the current example for s of sk examples in our meta-replay batch, it gets the same overall priority in both cases which is s times larger than that of a random example drawn from the buffer.

Original: The primary difference is that in MER we caneffectively leverage a greater number of effective Reptile steps k while also shifting up the priority of the  current example within the batch.
Revised: As such, we can also optimize an equivalent gradient using algorithm 6 because it uses a factor s to increase the priority of the gradient given to the current example. While β = 1 is an interesting special case of MER in algorithm 1, in general we ﬁnd it can be useful to set β to be a value smaller than 1. In fact, in our experiments we consider the case when β is smaller than 1 and γ = 1 . The success of this approach makes sense because the higher order terms in the Taylor expansion that reﬂect the mismatch between parameters across replay batches creates variance in the learning process.

Original: Now we would like to link the gradient being optimized for to the expected approximate objective function.
Revised: By setting β to a value below 1 we can reduce our comparative weighting on promoting inter batch gradient similarities rather than intra batch gradient similarities.

Original: It was noted in the Reptile paper that the following equality holds if the examples and order are random.
Revised: It was noted in the Reptile paper that the following equality holds if the examples and order are random:

Original: [Equation] 
Revised: [Equation] [Equation]

Original: In our work to make sure this equality holds in an online setting, we must take multiple precautions as noted in the main text.
Revised: In our work to make sure this equality holds in an online setting, we must take multiple precautions as noted in the main text.

Original: The issue is that examples are received in  sequence so when applied in an online setting the order is not totally random or arbitrary as in the original Reptile work.
Revised: The issue is that examples are received in a non-stationary sequence so when applied in a continual learning setting the order is not totally random or arbitrary as in the original Reptile work.

Original: We address  by maintaining our buffer using reservoir sampling, which ensures that any example seen before has a probability 1 N of being a particular element in the buffer.
Revised: We address this by maintaining our buffer using reservoir sampling, which ensures that any example seen before has a probability 1 N of being a particular element in the buffer.

Original: We also randomly select over these elements to form a batch.
Revised: We also randomly select over these elements to form a batch.

Original: As this makes the order largely arbitrary to the extent that our buffer includes all examples seen, we are approximating the random ofﬂine setting from the original Reptile paper.
Revised: As this makes the order largely arbitrary to the extent that our buffer includes all examples seen, we are approximating the random ofﬂine setting from the original Reptile paper.

Original: As such we can view the gradients in equation 16 and equation 36 as leading to approximately the following objective function:
Revised: As such we can view the gradients in equation 16 and equation 36 as leading to approximately the following objective function:

Original: [Equation]
Revised: [Equation]

Original: This is precisely equation 7 in the main text. 
Revised: This is precisely equation 7 in the main text. J S UPERVISED C ONTINUAL L IFELONG L EARNING

Revised: For the supervised continual learning benchmarks on MNIST Rotations and MNIST Permutations, following conventions, we use a two layer MLP architecture for all models with 100 hidden units in each layer.

Revised: We also model our hyperparameter search after (Lopez-Paz & Ranzato, 2017).

Revised: For Omniglot, following (Vinyals et al., 2016) we scale the images to 28x28 and use an architecture that consists of a stack of 4 modules before a fully connected softmax layer.

Revised: Each module includes a 3x3 convolution with 64 ﬁlters, a ReLU non-linearity and 2x2 max-pooling.

Original: C H YPERPARAMETER S EARCH
Revised: J. H YPERPARAMETER S EARCH

Original: Here we report the hyper-parameter grids that we searched over in our experiments.
Revised: Here we report the hyper-parameter grids that we searched over in our experiments.

Original: The best values for the MNIST Rotations (ROT) at each buffer size (ROT-5120, ROT-500, ROT-200), MNIST Permutations (PERM) at each buffer size (PERM-5120, PERM-500, PERM-200), Many Permutations (MANY) at each buffer size (MANY-5120, MANY-500), and Omniglot (OMNI) at each buffer size (OMNI-5120, OMNI-500) are noted accordingly in parenthesis.
Revised: The best values for the MNIST Rotations (ROT) at each buffer size (ROT-5120, ROT-500, ROT-200), MNIST Permutations (PERM) at each buffer size (PERM-5120, PERM-500, PERM-200), Many Permutations (MANY) at each buffer size (MANY-5120, MANY-500), and Omniglot (OMNI) at each buffer size (OMNI-5120, OMNI-500) are noted accordingly in parenthesis.

Original: • Online Learning – learning rate: [0.0001, 0.0003, 0.001 (PERM, ROT), 0.003 (MANY), 0.01, 0.03, 0.
Revised: • Online Learning – learning rate: [0.0001, 0.0003, 0.001 (PERM, ROT), 0.003 (MANY), 0.01, 0.03, 0.

Original: (OMNI)] • EWC – learning rate: [0.001 (OMNI), 0.003 (MANY), 0.01, 0.03 (ROT, PERM), 0.1, 0.3, 1.0] – regularization: [1, 3 (MANY), 10 (OMNI), 30, 100, 300 (ROT, PERM), 1000, 3000, 10000, 30000] • GEM – learning rate: [0.001, 0.003 (MANY-500), 0.01 (ROT, PERM, OMNI, MANY-5120), 0.03, 0.1, 0.3, 1.0] – memory strength ( γ ): [0.0 (PERM-500, MANY-500), 0.1 (PERM-200, MANY-200), 0.5 (OMNI), 1.0 (ROT-5120, ROT-500, ROT-200, PERM-5120)] 
Revised: (OMNI)] • EWC – learning rate: [0.001 (OMNI), 0.003 (MANY), 0.01, 0.03 (ROT, PERM), 0.1, 0.3, 1.0] – regularization: [1, 3 (MANY), 10 (OMNI), 30, 100, 300 (ROT, PERM), 1000, 3000, 10000, 30000] • GEM – learning rate: [0.001, 0.003 (MANY-500), 0.01 (ROT, PERM, OMNI, MANY-5120), 0.03, 0.1, 0.3, 1.0] – memory strength ( γ ): [0.0 (PERM-500, MANY-500), 0.1 (PERM-200, MANY-200), 0.5 (OMNI), 1.0 (ROT-5120, ROT-500, ROT-200, PERM-5120)] • Experience Replay – learning rate: [0.00003, 0.0001, 0.0003, 0.001, 0.003 (MANY)

Revised: [Table]

Original: • Experience Replay – learning rate: [0.00003, 0.0001, 0.0003, 0.001, 0.003 (MANY), 0.01 (ROT, PERM), 0.03 (OMNI), 0.1] – batch size ( k -1): [5, 10 (ROT-500, PERM-200), 25 (ROT-5120, PERM-5120, PERM500), 50 (OMNI, MANY-5120, ROT-200), 100, 250] • Meta-Experience Replay – learning rate ( α ): [0.01 (OMNI-5120), 0.03 (ROT, PERM, MANY), 0.1 (OMNI-500)] – within batch meta-learning rate ( β ): 1. – across batch meta-learning rate ( γ ): [0.03 (ROT-200, PERM-5120, MANY-5120, MANY-500), 0.1 (ROT-5120, ROT-500, PERM-500, PERM-200), 0.3, 1.0 (OMNI)] – batch size ( k -1): 
Revised: – batch size ( k -1): [5, 10 (ROT-500, PERM-200), 25 (ROT-5120, PERM-5120, PERM500), 50 (OMNI, MANY-5120, ROT-200), 100, 250] • Meta-Experience Replay – learning rate ( α ): [0.01 (OMNI-5120), 0.03 (ROT, PERM, MANY), 0.1 (OMNI-500)] – across batch meta-learning rate ( γ ): 1. – within batch meta-learning rate ( β ): [0.03 (ROT-5120, ROT-200, PERM-5120, PERM-200, MANY), 0.1 (ROT-500, PERM-500), 0.3, 1.0 (OMNI)] – batch size ( k -1): [5 (MANY-500, OMNI-500), 10, 25 (PERM-500, PERM-200, OMNI-5120), 50 (ROT-5120, PERM-5120,MANY-5120), 100 (ROT-200, ROT-500)] – number of batches per example: [1, 2 (PERM-500, OMNI-500), 5 (ROT-500, ROT200, PERM-200, OMNI-5120, MANY-5120), 10 (ROT-5120, PERM-5120, MANY500)] K F ORWARD T RANSFER AND I NTERFERENCE Forward transfer was a metric deﬁned in (Lopez-Paz & Ranzato, 2017) based on the average increased performance on a task relative to performance at random initialization before training on that task. Unfortunately, this metric does not make much sense for tasks like MNIST Permutations where inputs are totally uncorrelated across tasks or Omniglot where outputs are totally uncorrelated across tasks.

Original: [5 (MANY-500, OMNI-500), 10, 25 (PERM-500, PERM-200, MANY-5120, OMNI-5120), 50 (ROT-5120, ROT-500, PERM-5120), 100 (ROT-200)] – number of batches per example: [1, 2 (ROT-500, PERM-500, PERM-200, OMNI500), 5 (ROT-5120, ROT-200, OMNI-5120), 10 (PERM-5120, MANY-5120, MANY500)]
Revised: As such, we only provide performance for this metric on MNIST Rotations in Table 5. L A BLATION E XPERIMENTS In order to consider a version of GEM that uses reservoir sampling, we maintain our buffer the same way that we do for experience replay and MER. We consider everything in the buffer to be old data and solve the GEM quadratic program so that the loss is not increased on this data.

Revised: We found that considering the task level gradient directions did not lead to improvements.

Revised: M C ONTINUAL R EINFORCEMENT L EARNING

Revised: We detail the application of MER to deep Q-learning in algorithm 7, using notation from Mnih et al.

Revised: [Table]

Revised: ER with GEM style buffer

Original: [Table]
Revised: [Table]

Revised: GEM with Reservoir Sampling

Revised: [Table]

Original: D A BLATION E XPERIMENTS E C ONTINUAL R EINFORCEMENT L EARNING E. P ARAMETERS FOR C ONTINUAL R EINFORCEMENT L EARNING E XPERIMENTS
Revised: procedure DQN-MER( env, frameLimit, θ, α, β, γ, steps, k, E Q ) // Initialize action-value function Q with parameters θ : Q ← Q ( θ ) // Initialize action-value function ˆ Q with the same parameters ˆ θ = θ : ˆ Q ← ˆ Q (ˆ θ ) =

Revised: ˆ Q ( θ ) //

Revised: Initialize experience replay buffer:

Revised: M ← {}

Revised: M.age ←while M.age ≤ frameLimit do // Begin new episode: env.reset () //

Revised: Initialize the s state with the initial observation: while episode not done do // Select with probability p an action a from set of possible actions: a = (cid:26) random selection of action ˆ a p ≤ (cid:15) arg max a Q ( s t , a (cid:48) ; θ ) p > (cid:15) //

Revised: Perform the action a in the environment: s (cid:48) , r t ← env.step ( s, a ) //

Revised: Store current transition with reward r :

Revised: M ← M ∪ { ( s, a, r, s (cid:48) ) } (algorithm 3)

Revised: B 1 , ..., B steps ← sample ( s, a, r, s (cid:48) , steps, k, M ) //

Revised: Store current weights: θ A 0 ← θ for i = 1 , ..., steps do θ Wi, 0 ← θ for j = 1 , ..., k

Revised: do //

Revised: Sample one set of processed sequences, actions, and rewards from M : s, a, r, s (cid:48)

Revised: =

Revised: B i [ j ] y = (cid:40)

Revised: r if ﬁnal frame in episode r + Γ max a ˆ Q ( s (cid:48) , a ; ˆ θ ) otherwise //

Revised: Optimize the Huber loss H ( y, Q ( s, a ; θ Wi,j − 1 )) :

Revised: L ← H ( y, Q ( s, a ; θ Wi,j − 1 ))

Revised: θ Wi,j ← θ Wi,j − 1 − α ∂L ∂θ

Revised: ,j −end for //

Revised: Within batch Reptile meta-update: end for // batch Reptile update:

Revised: // Reset action-value network

Revised: Q

Revised: E Q of episodes:

Revised: Q end while end while return θ, M end procedure

Revised: M

Revised: D ESCRIPTION OF C ATCHER AND F LAPPY B IRD

Revised: In Catcher, the agent controls a segment that lies horizontally in the bottom of the screen, i.e. a basket, and can move right or left, or stay still.

Revised: The goal is to move the basket to catch as many pellets as possible.

Revised: Missing a pellet results in losing one of the three available lives.

Revised: Pellets emerge one by one from the top of the screen, and have a descending velocity that is ﬁxed for each task.

Revised: In the case of the very popular game Flappy Bird, the agent has to navigate a bird in an environment full of pipes by deciding whether to ﬂap or not ﬂap its wings.

Revised: The pipes appear always in pairs, one from the bottom of the screen and one from the top of the screen, and have a gap that allows the bird to pass through them.

Revised: Flapping the wings results in the bird ascending, otherwise the bird descends to ground naturally.

Revised: Both ascending and descending velocities are presets by the physics engine of the game.

Revised: The goal is to pass through many pairs of pipes as possible without hitting a pipe, as this results in losing the game.

Revised: The scoring scheme in this game awards a point each time a pipe is crossed.

Revised: Despite very simple mechanics, Flappy Bird has proven to be challenging for many humans.

Revised: According to the original game scoring scheme, players with a score of 10 receive a Bronze medal; with 20 points, a Silver medal; 30 results in a Gold medal, and any score better than 40 is rewarded with a Platinum medal.

Revised: M. DQN WITH M ETA -E XPERIENCE R EPLAY

Revised: The DQN used to train on both games follows the classic architecture from (Mnih et al., 2015): it has a CNN consisting of 3 layers, the ﬁrst with 32 ﬁlters and an 8x8 kernel, the second layer with 64 ﬁlters and a 4x4 kernel, and a ﬁnal layer with 64 ﬁlters and a 3x3 kernel.

Revised: The CNN is followed by two fully connected layers.

Revised: A ReLU non-linearity was applied after each layer.

Revised: We limited the memory buffer size for our models to 50k transitions, which is roughly the proportion of the total memories used in the benchmark setting for our supervised learning tasks.

Original: For the continual reinforcement learning setting we set the parameters using results from the experiments in the supervised setting as a guidance.
Revised: For the continual reinforcement learning setting we set the parameters using results from the experiments in the supervised setting as a guidance.

Original: Both Catcher and Flappy Bird used the same hyper parameters as detailed below with the obvious exception of the game-dependent parameter that deﬁnes each task.
Revised: Both Catcher and Flappy Bird used the same hyper parameters as detailed below with the obvious exception of the game-dependent parameter that deﬁnes each task.

Original: Models were trained with a maximum number of frames of 150k and 6 total tasks, switching every 25k frames.
Revised: Models were trained with a maximum number of frames of 150k and 6 total tasks, switching every 25k frames.

Original: Runs used different random seeds for the initialization as stated inthe ﬁgures.
Revised: Runs used different random seeds for the initialization as stated in

Original: • Game Parameters – Catcher: ∆ : 0 .
Revised: • Game Parameters – Catcher: ∆ : 0 .

Original: 03 (vertical velocity of pellet increased from default 0.608).
Revised: 03 (vertical velocity of pellet increased from default 0.608).

Original: – Flappy Bird: ∆ : − 10 (pipe gap decreased 10 from default 100).
Revised: – Flappy Bird: ∆ : − 5 (pipe gap decreased 5 from default 100).

Original: • Experience Replay – learning rate: 0.
Revised: • Experience Replay – learning rate: 0.

Original: – batch size ( k -1):• Meta-Experience Replay – learning rate ( α ): 0.
Revised: – batch size ( k -1):• Meta-Experience Replay – learning rate ( α ): 0.

Original: –  batch meta-learning rate ( γ ): 0.
Revised: – within batch meta-learning rate ( β ):– across batch meta-learning rate ( γ ): 0.

Original: – batch size ( k -1):– number of batches per example:– buffer size:
Revised: – batch size ( k -1):– number of steps:– buffer size:

Original: E. C ONTINUAL R EINFORCEMENT L EARNING E VALUATION FOR F LAPPY B IRD
Revised: M. C ONTINUAL R EINFORCEMENT L EARNING E VALUATION FOR F LAPPY B IRD

Original: Performance during training in continual learning for a non-stationary version of Flappy Bird is shown in Figure (4).
Revised: Performance during training in continual learning for a non-stationary version of Flappy Bird is shown in Figure (5).

Original: Graphsshow averaged values over three validation episodes across three different seed 
Revised: Graphsshow averaged values over three validation episodes across three different seed initializations. Vertical grid lineson the frame axis indicate task switch

Original: [Figure]
Revised: [Figure]