Lifetime policy reuse and the importance of task capacity

Abstract

A long-standing challenge in artificial intelligence is lifelong reinforcement learning, where learners are given many tasks in sequence and must transfer knowledge between tasks while avoiding catastrophic forgetting. Policy reuse and other multi-policy reinforcement learning techniques can learn multiple tasks but may generate many policies. This paper presents two novel contributions, namely 1) Lifetime Policy Reuse, a model-agnostic policy reuse algorithm that avoids generating many policies by optimising a fixed number of near-optimal policies through a combination of policy optimisation and adaptive policy selection; and 2) the task capacity, a measure for the maximal number of tasks that a policy can accurately solve. Comparing two state-of-the-art base-learners, the results demonstrate the importance of Lifetime Policy Reuse and task capacity based pre-selection on an 18-task partially observable Pacman domain and a Cartpole domain of up to 125 tasks.

Keywords

Lifelong learning reinforcement learning transfer learning catastrophic forgetting

1. The importance of efficient learning over multiple tasks

During their lifetime, animals may be subjected to a large number of unknown tasks. In some environmental conditions, nutritious food sources may be readily available, while in others they may be sparse, hidden, or even poisonous, and dangerous predators may roam in their vicinity. To address these challenging conditions, various behaviours must be selectively combined, such as avoidance, reward-seeking, or even fleeing. When direct perception provides limited or no cues about the current task, animals have to infer the task or use a strategy that works for many different tasks it may encounter. If task sequences are long and diverse, the animal may need to find different strategies, each of which apply to a large sub-domain of the tasks it encounters. Selecting how many such strategies are required represents a trade-off between optimality and the animal’s limited cognitive resources.

In artificial intelligence, variants of the above problem have been formulated within the field of lifelong learning [11,62,68], in which new tasks may appear at any time and where a learned task might be forgotten when it has not been seen regularly. The lifelong learning setting combines the problems of transfer learning and catastrophic forgetting into a single scenario. In transfer learning, learners should leverage the knowledge gained from a set of previously learned tasks with similar characteristics to a new task, whilst avoiding transferring knowledge that is not relevant [37,50,65]. In catastrophic forgetting, knowledge learned on one task removes or deteriorates knowledge learned on some previous tasks [19,22]. Due to combining both necessary aspects of learning as well as the emphasis on long-term problem solving, the lifelong learning setting is an exciting frontier for advancing modern artificial intelligence systems.

Lifelong reinforcement learning represents the intersection of reinforcement learning (RL) [64] and lifelong learning in the above sense. Lifelong RL requires representing the commonalities among tasks which may be done by considering a single policy with task-specific features or through multiple policies. Single policy learning emphasises feature sharing which is beneficial when it is known which aspects are task-specific and which are shared. Multi-policy learning has improved applicability to larger task sets with more widely varying tasks and it allows greater task specialisation within the task set. A key challenge is that to store solutions to different tasks, multi-policy RL (e.g. [17,25]) generates more policies as more tasks are presented, which results in excessive memory consumption. Moreover, in both single- and multi-policy RL, there is a fundamental challenge regarding the task capacity of policy representations: how many tasks can be represented or learned within a policy without a significant loss of performance? So far, this question has only been investigated indirectly by tracking forgetting and transfer metrics [32,65] or by growing a policy library until there is no more benefit of adding policies (e.g. [16]).

To address both challenges, this paper focuses on two novel contributions:

Lifetime Policy Reuse: a policy reuse algorithm which maintains a fixed-size policy library. The algorithm adaptively assigns policies to tasks based on bandit learning over the lifetime reinforcement on the different tasks. Contrasting to previous approaches, the algorithm is model-agnostic in the sense that it can take any base-learner as the underlying policy optimisation and exploration on the single-task level is preserved as is.

Measures for task capacity: the paper presents theoretical and empirical measures for task capacity, which can be used to determine how many policies to use in a lifelong RL problem. The theoretical task capacity applies arguments from representational capacity [4,18,20,28,56,71] to the multi-task multi-policy context. To account for sequential effects and learning, the empirical task capacity is based on the relative performance compared to task-specific policies.

Using lifetime policy reuse with pre-selection based on task capacity allows high performance in lifelong learning domains, as demonstrated in a Cartpole domain and a partially observable Pacman domain, both of which consist of a long sequence of randomly ordered tasks.

The paper is structured as follows. Section 2 provides preliminaries to the lifelong RL task sequences. Section 3 provides an overview of lifelong reinforcement learning algorithms and their relation to Lifetime Policy Reuse. Section 4 develops the three lifetime principles behind Lifetime Policy Reuse. Section 5 develops useful definitions of task capacity. Section 6 provides the experimental setup including lifelong learning domains and the various experimental conditions. Section 7 provides the performance evaluation of Lifetime Policy Reuse and analyses the impact of adaptive policy selection, the importance of task capacity, and the difference between the base-learners.

2. Reinforcement learning setup

In RL, an agent interfaces with the environment in the following control cycle. First, it receives the state of the environment, a state s from the state space $S$ that directly corresponds to a unique environment state, or a more limited observation, an observation o from the observation space $O$ that is only a partial observation of the environment state. Then, based on the full state, if it is observable, or else the more limited observation, it performs an action a according to its policy $π : S \to A$ where $A$ is the space of actions; and finally, it receives a real-valued reward r from the environment. The policy can be formulated explicitly or implicitly; for example, an often-used implicit approach is to define an action-value function Q, which represents the utility $Q (s, a)$ of any state-action pair $⟨ s, a ⟩$ , and then select the optimal action for the given state probabilistically according to the action-value function. To adaptively increase the reward intake over time, the learning agent will perform periodic updates to its value-function or directly to its policy. The policy and the value-function are often fitted through a function approximator, such as a deep neural network, to be able to solve larger state-action spaces.

The most common task-modelling frameworks in RL are Markov Decision Processes (MDPs) and Partially Observable Markov Decision Processes (POMDPs).

An MDP is defined by a tuple $⟨ S, A, T, r, γ ⟩$ , where: $S$ is the state space; $A$ is the action space; $T$ is the transition function that samples the next state $s_{t + 1}$ conditioned on the current state $s_{t}$ and the current action $a_{t}$ , i.e. $s_{t + 1} \sim T (s_{t}, a_{t})$ ; $r_{t} = r (s, a)$ denotes the real-valued reward at time t after performing action $a_{t}$ in state $s_{t}$ ; and $γ \in [0, 1]$ denotes the discount parameter that represents the patience in the value function $\begin{matrix} (1) & V (s_{t}) = E_{π, T} [\sum_{j = t}^{t + H} γ^{j - t} r (s_{j}, a_{j})], \end{matrix}$ where H is the horizon. An action-specific Q-function is often formulated as $V (s_{t}) = {max}_{a \in A} Q (s_{t}, a_{t})$ . Due to the transition function being state-action dependent, the MDP follows the Markov property such that $P (s_{t + 1} | s_{t} a_{t}) = P (s_{t + 1} | s_{t} a_{t} \dots s_{1} a_{1})$ .

The POMDP generalises the MDP to account for partial observability of the current environment state, making it more widely applicable. The POMDP $⟨ S, A, T, r, γ, O, T_{o} ⟩$ assumes an underlying MDP but additionally incorporates an observation space $O$ and an observation transition function $T_{o}$ , such that $o_{t + 1} \sim T_{o} (s_{t + 1}, a_{t})$ is the observation following action $a_{t} \in A$ in the reached state $s_{t + 1} \in S$ . In POMDPs, the observations are input to the learning agent, rather than the states, and the Markov property does not hold for the observations. That is, it is not required that $P (o_{t + 1} | o_{t} a_{t} \dots o_{1} a_{t}) = P (o_{t + 1} | o_{t} a_{t})$ . However, the states of the underlying MDP still follow the Markov property. The MDP can therefore be seen as a special-case POMDP in which observations and states are always equal such that $O = S$ and $T_{o} = T$ .

While traditional RL solves a single MDP or POMDP, this paper will focus on how to solve lengthy sequences of randomly presented MDPs and POMDPs.

3. Lifelong reinforcement learning: A review

Lifelong reinforcement learning (LRL) is one of the branches of lifelong learning which focuses on the problem setting of RL. This section surveys the field, identifying scalability to a large number of widely varying tasks and applicability to different base-learners as key gaps in the current state-of-the-art.

3.1. Single-policy methods

Most LRL approaches consider how to learn with a single policy and provide some task-specific aspects. The main aim of this approach is that it allows transferable features to be efficiently learned within a single representation while adding some additional task-specificity. Specificity may be represented in architectural components or within the training algorithm itself to improve performance on multiple tasks [15,29,30,34,43,55,57]. While a single policy is compact and the neural network’s hidden layers close to the input layer are able to represent transferable features, it can bring disadvantages. The number of neurons may grow with the number of tasks [55], or expert knowledge of the task’s relevant features may be needed as inputs to the learning system [15,57]. Further, there may be no common representation to all tasks; for example, one lifelong learning approach, which reused a single Deep Q-Network policy on all of the tasks, has also been outperformed by task-specific DQN policies [34,46]. More generally, these approaches typically have a few limiting assumptions on the relation between tasks. For example, [12] and [38] require some bounds on the change in reward function and transition function, implying it is more suited to continuously changing scenarios rather than a sequence of tasks from a wide task domain. Techniques and insights relevant for single-policy RL may also be found in related fields; for example, parameter sharing for multi-agent RL [21,66], which uses a single-network to represent all policies of the agents but which may add agent indicators to the observation to account for heterogeneity of different agents.

3.2. Policy reuse

To avoid some of the above-mentioned challenges, some have recognised the need for learning with multiple policies. In particular, policy reuse methods learn a limited number of policies each specialised to their own subset of tasks as a means to improve transfer to a new unseen task [16,40,42,52,73]. The approach represents a step forward in improving the scalability of multiple policy approaches as some empirical results have shown the viability of transfer learning. For example, 50 tasks in an office domain were learned with 14 Q-learning policies; the results show this was possible by learning a common policy for all of the tasks which have their goal locations in the same room [16,74]. While there have been recent advances in policy reuse which demonstrate improved transfer on a smaller number of tasks (e.g. [40]), the high number of 50 tasks in [16] has not been replicated in other LRL studies (policy reuse or otherwise). Of primary interest here, the high number of tasks indicates policy reuse as a promising approach for scalable LRL.

To scale the policy reuse approach to memory-consuming deep reinforcement learners or to even more policies than is currently the case, current methods have their limitations. In particular, online learning of the policy library without generating too many temporary or permanent policies remains a challenge in policy reuse. Most works have focused on how to select the new policy for a new, unlabeled task (see e.g. [52]). Other works have provided tools to build the policy library. In [16], new, temporary policies are formed for new tasks and these may be added to the library if after convergence on the task the resulting policy performs significantly better than the existing policies in the library. A downside of this method is that when convergence is not allowed, and many tasks are randomly presented, memory issues may become apparent. In [25], one also forms new policies for new tasks but all policies are added to the library, which implies memory issues will be apparent even more rapidly.

Policy reuse has been limited in its applicability as base-learners other than Q-learning methods have yet to be incorporated with policy reuse. This would be particularly desirable after results suggesting Q-learning may not be optimal for reuse, since (i) policy reuse with Q-learning policies may result in negative transfer, being outperformed by task-specific Q-learning [40]; and (ii) a single-policy lifelong learning approach with DQN has been outperformed by task-specific DQN policies [34,46].

3.3. Alternative multi-policy methods

A variety of alternative approaches have been taken to multi-policy LRL. These methods assume some similarity across all tasks and are therefore not the method of choice to learn large sets of tasks with widely varying dynamics and reward functions.

One approach is to provide an initial policy based on the prior tasks and then generate a new policy for each additional task encountered during operation [1,17,35,69,75]. However, each task requires a new policy to be stored, causing memory problems when a long sequence of tasks is considered. Moreover, finding an initial policy may be difficult to locate in parameter space when tasks require widely differing policies.

Hierarchical approaches are proposed to improve transfer learning by learning sub-policies that achieve a subgoal or search for a rewarding high-level state [8,35,41,67,68]. Sub-policies used in this way represent solutions to sub-tasks which occur across a number of different tasks, reducing the number of required policies. While there are a few exceptions (e.g., [39]), a downside of this approach is that (i) there is a need for two separate phases, one to learn sub-policies, and one to combine them; and (ii) that tasks may come in clusters in which similar tasks are more efficiently solved by a common policy.

3.4. Meta-learning

Meta-learning, in which a meta-level algorithm optimises the underlying learning algorithm itself by means of a meta-level objective, has been investigated in domains relevant for lifelong learning. In general, such methods share key aims, such as learning over an extended lifetime and improving generalisation but do not consider the same learning setting or the same goal to learn widely varying task sequences.

Meta-learning methods are particularly prevalent in supervised learning. For example, hyper-networks, in which a top-level super-ordinate network performs gradient descent to optimise a sub-ordinate network, can solve a variety of tasks from within a similar class [2,27].

In meta-RL, the literature focuses on generic aspects of RL such as improved exploration (e.g., [76]). Other meta-RL approaches have focused specifically on settings relevant to lifelong learning: multi-task learning, in which multiple tasks are learned in batch (e.g., [17]); continual learning, in which a limited number of similar tasks of increasing difficulty are presented (e.g., [51]); and lifetime RL methods that are guided by the lifetime average reward to improve the system in long-term environments (e.g., [6]). The lifetime policy reuse method is partly inspired by the latter approach.

4. Lifetime policy reuse

Lifetime Policy Reuse avoids excessive memory consumption by using a number of policies fixed at design-time which are continually refined based on incoming tasks across the lifetime. Contrasting to earlier policy reuse systems [16,52,73], Lifetime Policy Reuse has the following features (to which it owes its name):

Rather than assuming convergence on the task, the successive presentation of one task may be a much more limited number of episodes as part of a much longer randomised sequence, and the policies in the library are adjusted throughout the entire lifetime of the RL agent based on the subset of tasks they are assigned to.

Policies are assigned to subsets of tasks by comparing their lifetime average reward compared to the other policies.

The number of policies is fixed at all times, and thereby it scales better to lengthy lifetimes with many tasks.

The following provides a concrete description of Lifetime Policy Reuse, including the problem setting (see Section 4.1), the policy selector, details on the adaptive mechanism for policy selection (Section 4.2), and the model-agnostic algorithm (see Section 4.3). The full algorithm of Lifetime Policy Reuse is described with pseudo-code in Algorithm 1.

Algorithm 1

Lifetime policy reuse algorithm with conservative ϵ-greedy policy selector

4.1. Problem setting

Let $F = {τ_{1}, τ_{2}, \dots, τ_{N_{τ}}}$ be a finite set of unique RL tasks, either MDPs or POMDPs. The tasks share the same state-action space and discount factor but come with their own reward functions ${r^{τ_{1}}, \dots, r^{τ_{N_{τ}}}}$ as well as their own transition dynamics ${T^{τ_{1}}, \dots, T^{τ_{N_{τ}}}}$ .

The task sequence consists of consequent task-blocks, each of which is a time interval during which the same task is repeated for a number of episodes (or a particular time interval for non-episodic environments). At the start of each task-block, the current task τ is sampled with replacement from an unknown distribution $P [F]$ over the set of tasks $F$ . Then τ is presented until the end of the task-block. Task-blocks may be relatively short so that full convergence is not guaranteed on the task leading to the potential for catastrophic forgetting (i.e. a performance reduction upon revisiting the same task) as well as negative transfer (i.e. a performance reduction after learning other tasks).

The goal is to develop a fixed number of policies by assigning to each policy their best task specialisation based on their task-specific lifetime average $R_{i j} = \frac{1}{t_{i j}} \sum_{k = 0}^{t_{i j}} r_{i j} (k)$ , where i is the policy, j is the task index, $k = 0$ is the start of the lifetime, $t_{i j}$ is the number of time units that policy i spent in task $τ_{j}$ , and $r_{i j} (k)$ is the reward obtained at time step k of applying policy i in task $τ_{j}$ .

The task-specific lifetime average reward is favoured over a few alternatives as the objective of the adaptive policy selector. First, the jumpstart, which is the performance difference at the start of the new task, and the most rapid improvement, which considers the improvement in performance over an initial time interval in the new task, may lead to rapid initial improvement but may be followed by stagnation. Second, while the asymptotic performance on the task is especially important for long-term scenarios, it is unknown during the learning process and therefore cannot provide online learning; instead, the lifetime average performance on the task allows online, incremental learning of which policy to select and if it converges, it converges to the asymptotic performance. Third, while the discounted cumulative reward is used to optimise the policies, this objective is not used in the policy selection because discounting defines the solution method (i.e., low-patience vs high-patience) rather than the goal. To give a practical example, in Pacman or Atari games, the RL community evaluates the performance of algorithms not on the objective of the learner but on the actual score, be it asymptotic or lifetime average performance. Discounting in continuing environments does not optimise the lifetime average but the lifetime average does (see e.g., [47]).

4.2. Policy selector

In Lifetime Policy Reuse, there is a natural trade-off between exploration, selecting an untested policy for the task, and exploitation, selecting the well-tested policy for the task. Bandit algorithms such as Upper Confidence Bound (UCB) and ϵ-greedy are therefore prime candidates to function as policy selectors. The experiments in this paper will use ϵ-greedy as policy selector. At the start of each episode, ϵ-greedy selects the best policy with a probability $1 - ϵ$ and a randomly chosen policy in Λ with probability ϵ, where ϵ is a small probability, here set to $ϵ = 0.10$ to give sufficient opportunities to train the current best policy. The initial policy is chosen randomly and as long as a policy has not been selected for a task yet it cannot be the best policy and therefore can only be chosen with a probability of $ϵ / N_{π}$ ; this conservative bias aims to first train the best policy repeatedly before selecting another policy, which avoids being inefficient when there are many policies and when reliable evaluation of a policy requires many episodes. ϵ-greedy provides a higher performance compared to UCB (see Section 7.1 vs Appendix B), which is due to it providing a stable specialisation compared to UCB’s frequent alternation between policies observed even at the end of the lifetime.

4.3. Model-agnostic algorithm

The algorithm first initialises a library of policies $Λ = {π_{1}, \dots, π_{N_{π}}}$ randomly in parameter space. At the start of each episode, the policy selector decides on the policy to be used for the current task based on the lifetime average reward. At any given time step within an episode, the selected policy interfaces with the environment as the base-learner would do in a traditional single-policy approach, including action selection as well as training and other parameter updates. After the episode finishes, a new policy is chosen by the policy selection module and the cycle repeats. The algorithm is illustrated in Fig. 1 and described in pseudo-code in Algorithm 1. While further details on the algorithmic behaviour are base-learner and policy selector dependent, the model-agnostic algorithm results in specialising policies to selected subsets of tasks.

Fig. 1.

Lifetime policy reuse. The following cycle is repeated: first, a policy selector selects a policy to be used; second, the policy interfaces with the environment for a prolonged amount of time (e.g. one episode), during which time it not only acts but also learns in the environment. When the policy has finished, it feeds back its performance to the policy selector.

5. Task capacity

Lifelong reinforcement learning algorithms would greatly benefit from measures that help to determine how many tasks they can learn. In Lifelong Policy Reuse, for example, this would help to select a suitable number of policies, $N_{π}$ . This of critical importance since, if the number of policies is too low, then the learning agent may experience negative transfer and catastrophic forgetting; if the number of policies is too high, this may lead to excessive memory consumption or slower learning on new tasks that are similar to previously seen tasks. This section proposes two measures for the task capacity: (i) the theoretical task capacity, the number of tasks that a policy can represent to sufficient accuracy; and (ii) the empirical task capacity, the number of tasks that a policy can empirically learn to sufficient accuracy. The theoretical task capacity being purely representational does not require any preliminary runs while the empirical task capacity does but additionally accounts for learning properties and can serve as a benchmarking tool.

5.1. Solving multiple tasks accurately

A near-optimal lifetime policy reuse system yields for each task $τ \in F$ a lifetime average reward, $R^{τ} = E_{π, T^{τ}} [\frac{1}{T} \sum_{t = 0}^{T} r^{τ} (s_{t}, π (s))]$ , close to or equal to the optimal lifetime average reward, $R^{τ *} = E_{π^{τ *}, T^{τ}} [\frac{1}{T} \sum_{t = 0}^{T} r^{τ} (s_{t}, π^{τ *} (s))]$ , where π is the policy chosen for task τ and $π^{τ *}$ is the optimal policy for task τ. Defining the lifetime regret for a policy $π_{θ}$ on task τ as $L (θ; τ) = R^{τ *} - R^{τ}$ , a near-optimal reinforcement learner has a negligible lifetime regret on all tasks in $F$ , which is formalised below through the notion of an epsilon-optimal partition (see Lemma 1).

In addition to providing a notion of near-optimality, Lemma 1 below provides a sufficiency condition that illustrates that to obtain near-optimal policies, it is sufficient to analyse the states in which the policy performs sub-optimally. The lemma will make the following assumptions. First, rewards and expected rewards are normalised in $[0, 1]$ , which is not a limiting assumption as these can be scaled to obtain a more general case. Second, the tasks are continuing MDPs. The tasks are continuing in the sense that either the task is non-episodic or the different episodes are converted into a single MDP. In the latter case, one can re-design the reward function to penalise shorter episodes and define the transition from the terminal state as the initial state distribution. With the above assumptions, the lemma will make use of a task-specific occupation measure $P [s | π_{θ}, τ] = \frac{1}{T_{τ}} \sum_{t = 1}^{T_{τ}} I (s_{t} = s | τ)$ , which, based on the indicator $I$ , defines for a task τ the expected fraction of time spent in state $s \in S$ when compared to the total time $T_{τ}$ .

Lemma 1.
An epsilon-optimal partition defines for a given task $τ \in F$ a subset of parameter space $Θ_{ϵ} \subset Θ$ such that for each $θ \in Θ_{ϵ}$ , the policy $π_{θ}$ parametrised by θ satisfies $L (θ; τ) ⩽ ϵ R^{τ }$ . Define the optimal policy* $π^{τ }$ , arbitrary* $ϵ ⩾ 0$ , $S^{-} = {s \in S : r^{τ} (s, π_{θ} (s)) \neq r^{τ} (s, π^{τ } (s))}$ . Then* $θ \in Θ_{ϵ}$ if $\sum_{s^{'} \in S^{-}} P [s^{'} | π_{θ}, τ] r^{τ} (s^{'}, π_{θ} (s^{'})) ⩽ ϵ R^{τ }$ .

Proof: For arbitrary $θ \in Θ$ , its corresponding policy $π_{θ}$ will have a set of states $S^{+} \subset S$ for which its chosen action yields $r^{τ} (s, π_{θ} (s)) = r^{τ} (s, π^{τ } (s))$ for task $τ \in F$ , while for the remainder of the states $S^{-} = S ∖ S^{+}$ its action chosen yields $r^{τ} (s, π_{θ} (s)) < r^{τ} (s, π^{τ } (s))$ . Setting the expected reward for any $s \in S^{-}$ minimally, 0, for $π_{θ}$ allows dropping the summation over $S^{-}$ in the equality $R^{τ} = \sum_{s \in S^{-}} P [s | π_{θ}, τ] r^{τ} (s, π_{θ} (s)) + \sum_{s^{'} \in S^{+}} P [s^{'} | π_{θ}] r^{τ} (s^{'}, π^{τ } (s^{'}))$ , and yields the following upper bound to the regret: $\begin{array}{r} L (θ; τ) ⩽ R^{τ } - \sum_{s^{'} \in S^{+}} P [s^{'} | π_{θ}, τ] r^{τ} (s^{'}, π_{θ} (s^{'})) . \end{array}$ Therefore, $θ \in Θ_{ϵ} \subset Θ$ if $\begin{aligned} L (θ; τ) ⩽ ϵ R^{τ } \\ \sum_{s^{'} \in S^{+}} P [s^{'} | π_{θ}, τ] r^{τ} (s^{'}, π_{θ} (s^{'})) ⩽ (1 - ϵ) R^{τ } \\ \sum_{s^{'} \in S^{-}} P [s^{'} | π_{θ}, τ] r^{τ} (s^{'}, π_{θ} (s^{'})) ⩽ ϵ R^{τ }, \end{aligned}$ which concludes the proof.

Lemma 1 implies that to find an ϵ-optimal policy, it is sufficient to focus on those states $s \in S^{-}$ in which its reward differs from that of the optimal policy. This result is especially useful for those MDPs where there is only a small subset of the states that contributes to the regret. The Cartpole MDP is an instance of such MDPs as the only sub-optimal states are those near termination; therefore the theoretical task capacity within a Cartpole MDP domain can be assessed by analysing states just before termination (see Section 5.2).

Further, Lemma 1 comes with two corollaries.
Corollary 1.
Changing transition dynamics limits transferability. Let $τ, τ^{'} \in F$ , $r^{τ^{'}} = r^{τ}$ , and $T^{τ} \neq T^{τ^{'}}$ . Let $π_{θ}$ be a policy that satisfies $\sum_{s^{'} \in S^{-}} P [s^{'} | π_{θ}, τ] r^{τ} (s^{'}, π_{θ} (s^{'})) ⩽ ϵ R^{τ }$ as in Lemma* 1 . Then the analogous result for $τ^{'}$ , namely $\begin{array}{r} \sum_{s^{'} \in S^{-}} P [s^{'} | π_{θ}, τ^{'}] r^{τ^{'}} (s^{'}, π_{θ} (s^{'})) ⩽ ϵ R^{τ }, \end{array}$ holds if* $\begin{array}{r} \sum_{s \in S^{-} (τ)} Δ P [s | π_{θ}] L (θ, s) ⩽ ϵ Δ R^{}, \end{array}$ where* $Δ R^{} : = R^{τ^{'} } - R^{τ }$ , $Δ P [s | π_{θ}] : = P [s | π_{θ}, τ^{'}] - P [s | π_{θ}, τ]$ , and* $L (θ, s) : = r^{τ } - r^{τ} (s, π_{θ} (s)) = r^{τ^{'} } - r^{τ^{'}} (s, π_{θ} (s))$ .

Proof: Let $θ \subset Θ$ for which $\begin{array}{r} \sum_{s^{'} \in S^{-}} P [s^{'} | π_{θ}, τ] r^{τ} (s^{'}, π_{θ} (s^{'})) ⩽ ϵ R^{τ } . \end{array}$ Then $π_{θ}$ is an epsilon-optimal policy for task τ. However, for another task $τ^{'} \neq τ$ with different transition dynamics model $T$ , the policy π yields a different occupation measure $P [s | π_{θ}, τ^{'}]$ . Since $r^{τ^{'}} = r^{τ}$ and therefore also $S^{-} (τ) = S^{-} (τ^{'})$ , any increase in regret can only come from more visitations of $S^{-} (τ)$ . Therefore, the added regret $δ (τ, τ^{'})$ can be upper-bounded by $\begin{aligned} δ (τ^{'}, τ) & ⩽ \sum_{s \in S^{-} (τ)} Δ P [s | π_{θ}] L (θ, s) . \end{aligned}$ Consequently, ϵ-optimality on $τ^{'}$ requires that $\begin{aligned} L (θ; τ^{'}) & = L (θ; τ) + δ (τ^{'}, τ) \\ ⩽ ϵ R^{τ } + δ (τ^{'}, τ) \\ ⩽ ϵ R^{τ } + \sum_{s \in S^{-} (τ)} Δ P [s | π_{θ}] L (θ, s) \\ ⩽ ϵ R^{τ^{'} } \end{aligned}$ implying $\begin{array}{r} \sum_{s \in S^{-} (τ)} Δ P [s | π_{θ}] L (θ, s) ⩽ ϵ Δ R^{}, \end{array}$ concluding the proof.

When a given a policy $π_{θ}$ satisfies an ϵ-optimality guarantee of the type in Lemma 1, but the transition dynamics change, Corollary 1 provides a guarantee for transferring tasks if their expected change in regret due to visiting sub-optimal states is lower than a fraction of the change in optimal regret.
Corollary 2.
Changing reward functions limits transferability.* Let $τ, τ^{'} \in F$ , $r^{τ^{'}} \neq r^{τ}$ , and $T^{τ} = T^{τ^{'}}$ . Let $π_{θ}$ be a policy that satisfies $\sum_{s^{'} \in S^{-}} P [s^{'} | π_{θ}, τ] r^{τ} (s^{'}, π_{θ} (s^{'})) ⩽ ϵ R^{τ }$ as in Lemma* 1 . Then the analogous result for $τ^{'}$ , namely $\begin{array}{r} \sum_{s^{'} \in S^{-}} P [s^{'} | π_{θ}, τ^{'}] r^{τ^{'}} (s^{'}, π_{θ} (s^{'})) ⩽ ϵ R^{τ } \end{array}$ holds if* $\begin{array}{r} \sum_{s \in S^{c}} P [s | π_{θ}, τ] Δ L (θ, s) ⩽ ϵ Δ R^{} \end{array}$ for* $S^{c} : = {s \in S : r^{τ} (s) ⩾ r^{τ^{'}} (s) \land s \in S^{-} (τ^{'})}$ , $Δ L (θ, s) : = r^{τ} (s, π_{θ} (s)) - r^{τ^{'}} (s, π_{θ} (s))$ , and $Δ R^{} : = R^{τ^{'} } - R^{τ }$ .

Proof: Since $P [s | π_{θ}, τ] = P [s | π_{θ}, τ^{'}]$ , any increase in regret can only come from more visitations of states in $S^{c} = {s \in S : r^{τ} (s) ⩾ r^{τ^{'}} (s) \land s \in S^{-} (τ^{'})}$ , because these have their reward reduced in task $τ^{'}$ . The added regret $δ (τ, τ^{'})$ can therefore be upper-bounded by $\begin{aligned} δ (τ^{'}, τ) & ⩽ \sum_{s \in S^{c}} P [s | π_{θ}, τ] Δ L (θ, s) . \end{aligned}$ Therefore, $\begin{aligned} L (θ; τ^{'}) & = L (θ; τ) + δ (τ^{'}, τ) \\ ⩽ ϵ R^{τ } + δ (τ^{'}, τ) \\ ⩽ ϵ R^{τ } + \sum_{s \in S^{c}} P [s | π_{θ}, τ] Δ L (θ, s) \\ ⩽ ϵ R^{τ^{'} } \end{aligned}$ implying $\begin{array}{r} \sum_{s \in S^{c}} P [s | π_{θ}, τ] Δ L (θ, s) ⩽ ϵ Δ R^{}, \end{array}$ where $Δ R^{} = R^{τ^{'} } - R^{τ }$ , concluding the proof.

When a given a policy $π_{θ}$ satisfies an ϵ-optimality guarantee of the type in Lemma 1, but the reward function changes, Corollary 2 provides a guarantee for transferring if the changed states (i.e. those for which the reward function is different) contribute at most an ϵ-fraction of the optimal regret.

When both reward function and transition dynamics are dissimilar, transferability of one task to another is low, resulting in scalability issues. This effect can be observed in a sequence of POcman tasks, where many policies are required for epsilon-optimality across the task set (see Section 7). By contrast, the Cartpole problem maintains the same reward function across tasks, improving the overlap between tasks.
5.2. Theoretical task capacity

Epsilon-optimality introduced in Lemma 1 can be used to define how many policies are needed or equivalently, how many tasks a single policy can represent accurately. This quantity, called the theoretical task capacity, is defined below and illustrated on simple examples as well as the 27-task cartpole domain, which will be revisited in Section 6.3.

The theoretical task capacity is defined representationally based on (i) the hypothesis class $H$ , the set of allowed policy representations (for example, the set of functions that can be fitted by the function approximator); (ii) the task set $F$ ; and (iii) the tolerance, ϵ, specified for epsilon-optimality.

Definition 1.
The theoretical task capacity C of a hypothesis class $H$ with regard to a task set $F$ is the average number of tasks per policy when selecting the minimal number of policies, $N_{π}$ , that still ϵ-optimally represents all the tasks, $\begin{array}{rcl} C (H, F, ϵ) & = & max_{N_{π}} N_{τ} / N_{π} : \exists Λ = {π^{1}, \dots, π^{N_{π}}} \subset H : \forall τ \in F : \\ (2) & \exists π_{θ} \in Λ : L (θ; τ) ⩽ ϵ R^{τ }, \end{array}$ where $N_{τ}$ is the number of tasks and $N_{π}$ is the number of policies.

An important aspect of the theoretical task capacity is its dependency on the task set $F$ . A higher number of tasks in the set leads to a higher upper bound on the task capacity. Whether the task capacity is actually increased will depend on the task similarity. To illustrate this principle, consider what happens when formulating a task space based on a few defining task dimensions, similar to the construction of the Cartpole domain (see Section 6.3). If the number of tasks increases and the task bounds are expanded, then the task capacity could potentially be reduced. If the number of tasks increases but the task bounds stay the same, then the theoretical task capacity is increased due to tasks in the set being similar; this feature is convenient when one has analysed the number of policies needed for a coarse-grained version of a larger task domain (see the 125-task domain in Section 7.3).

Simple examples.* To illustrate the representational argument made for selecting the number of policies, below are two examples on how the representation of the base-learner limits its theoretical task capacity for a given task set.
Example 1.
Linear approximators for changing reward functions. In this example, a set of 4 polynomial functions must be approximated, providing a simple example in which transition dynamics do not play a role but the reward function changes depending on the task. A policy here simply outputs the estimated function output, with 100% probability. States are sampled independently and identically from a uniform distribution over the state space $S = [0, 1]$ . Consider a task set $F = {τ_{1}, τ_{2}, τ_{3}, τ_{4}}$ . Each of its four tasks are defined by the corresponding functions to approximate: $f_{1} (s) = - s^{2} + 2 s$ , $f_{2} (s) = s^{2}$ , $f_{3} (s) = - 0.01 s^{2} + 0.02 s$ , and $f_{4} (s) = 0.01 s^{2}$ ; in other words, $π_{τ_{i}}^{} (s) = f_{i}$ for all $i \in 1, \dots, 4$ . Their reward function is the complement of the absolute error, that is, $r^{τ_{i}} (s, π (s)) = 1 - | π (s) - τ_{i} (s) |$ for all $i \in {1, \dots, 4}$ . Consider the hypothesis class to be linear classifiers of the form $π (s) = A s$ where $A \in R$ is a constant.

Since the minimal number of linear functions that can be selected while maintaining expected error smaller than $ϵ = 0.25$ is $N_{π} = 2$ , the theoretical task capacity on this task set of size $N_{τ} = 4$ is given by $C = N_{τ} / N_{π} = 2$ . An example of such a function set is ${π^{1} (s) = s, π^{2} (s) = 0.01 s}$ . $π^{1} (s)$ can approximate $f_{1}$ and $f_{2}$ with an expected error of $\int_{0}^{1} s - s^{2} d s = 1 / 6$ . However, $π^{1}$ cannot fit $f_{3}$ or $f_{4}$ to ϵ-precision, since for $f_{3}$ the expected error is $\int_{0}^{1} s + 0.01 s^{2} - 0.02 s d s = 0.493 > ϵ$ and the expected error for $f_{4}$ is even larger. The function $π^{2} (s) = 0.01 s$ can fit both $f_{3}$ and $f_{4}$ with an error of $0.01 \int_{0}^{1} s - s^{2} d s = 1 / 600$ .
Example 2.
State-action pair representations for changing transition dynamics. In this example, a set of 6 RL tasks have different transition dynamics but are otherwise the same, with state space $S = {0, 1, 2, 3, 4}$ , action space $A = {- 1, + 1}$ , the initial state $s_{0} = 0$ , and the reward function r gives a reward equal to the number of successive steps going successfully in one direction. Each task in $F = {τ_{1, 2}, τ_{2, 3}, τ_{3, 4}, τ_{3, 2}, τ_{2, 1}, τ_{1, 0}}$ is identified by its unique transition model. For all $τ_{i, j} \in F$ , the transition model $T^{τ_{i, j}}$ defines $T^{τ_{i, j}} (s, a) = max (0, min (s + a, 4))$ except that transitioning from state i to state j is not allowed.

Each task $τ \in F$ has reachable states, $R^{+} (τ)$ , states that can be repeatedly visited until the end of the task, as well as unreachable states, $R^{-} (τ)$ , and the expected reward varies across tasks. For example, in $τ_{2, 3}$ the optimal task-specific strategy is to take $a = + 1$ until $s = 2$ , take $a = - 1$ until $s = 0$ , etc. because state $s = 3$ is not reachable. The optimal expected reward is $(0 + 1) / 2 = 0.5$ , $(0 + 1 + 2) / 3 = 1$ , or $(0 + 1 + 2 + 3) / 4 = 1.5$ , respectively, depending on the number of reachable states. Executing a policy optimal for one task τ will be sub-optimal for another task $τ^{'}$ , with an expected reward of 0 when the agent will attempt to keep moving either forward or backward but get stuck, or an expected reward of $\sum_{i = 0}^{N - 1} \frac{i}{N}$ , where $N = | R^{+} (τ) |$ , as the agent will go back and forth over the smaller path spanned by $R^{+} (τ)$ . A more expressive reinforcement learner with memory of the previous state could solve multiple tasks satisfactorily by switching direction if it observes its state is the same as before. Due to extending the path with one additional time step of standing still, the expected reward would be reduced by a factor $\frac{N}{N + 1}$ compared to optimal, where N is the number of reachable states for the task to be solved. Therefore, a single policy would be able to solve tasks for which $N ⩾ 3$ with a regret of $L (θ; τ) ⩽ ϵ R^{τ }$ where $ϵ = 0.25$ , but not other tasks with $N < 3$ , which would come with greater regret. The number of policies needed is therefore lower-bounded by $N_{π} ⩾ 2$ . However, by defining policies which move back and forth in $[0, 1]$ , $[0, 2]$ , $[0, 3]$ , $[1, 4]$ , $[2, 4]$ ,and $[3, 4]$ , the setting $N_{π} = 6$ provides an upper bound to the required policies as this solves all the tasks optimally. Therefore, the corresponding task capacity is bounded by $1 ⩽ C ⩽ 3$ .

Task cluster analysis of the 27-task Cartpole domain. When exact arguments are not possible, as is the case for deep-reinforcement learners in relatively complex tasks, the theoretical task capacity can be roughly approximated by identifying distinct clusters of tasks. This cluster analysis is now exemplified for deep reinforcement learners on the 27-task Cartpole domain, a domain that will be revisited in the empirical experiments of this paper.

The Cartpole domain includes different MDPs characterised by different transition dynamics. In this domain, a cart must balance a pole placed on its top by moving left or right with fixed force of 1 N. Each time step is rewarded with $+ 1$ but the episode terminates when (a) the pole has an angle of more than $15^{\circ}$ from vertical; (b) when the distance of the cart to the centre is greater than $2.4 m$ ; or (c) 200 time steps are completed, in which case the solution is considered optimal. 27 different tasks are formed in this domain by varying pole length, pole mass, and cart mass. In general, the optimal strategy is to move left when the pole turns left and to move right when the pole turns right. Many actions will come with equal reward of $+ 1$ , i.e. all those that do not finish the episode.

A single deep RL policy can represent a single task accurately since it can map arbitrary states onto arbitrary low-entropy probability distributions over actions. However, by Corollary 1, when different MDPs have different transition dynamics, a subset of such tasks will make the policy reach states in which its action is suboptimal. In the Cartpole domain, such suboptimal states can only be the states preceding the above-mentioned terminal states of the type (a) and (b); these states are followed by a reward of 0 while all others are followed by a reward of 1. Therefore, relevant differences in policy requirements across tasks can be identified by observing for each task which states lead to cases (a) and (b) and how frequently.

A computationally cheap experiment is performed, requiring only a few minutes runtime. The experiment tests a random uniform policy on all 27 tasks for 600,000 time steps each, which amounts to 20,000 to 60,000 episodes depending on task difficulty. Since case (b) is observed rarely (at most 15 times), while case (a) happens between 17,000 and 30,000 times, depending on the length of the cart, the focus is on which states precede event (a) and how frequently. In this analysis, clear differences in the angular velocity and the episode length before event (a) are observed across tasks. The cartpole problem is symmetric, so the lowest absolute angular velocity is computed as a boundary between the safe and unsafe regions. With this methodology, 8 clusters of nearby points are observed, with means ${(0.026, 17.5), (0.026, 30), (0.0125, 30), (0.013, 17.5), (0.006, 17.5), (0.006, 30), (0.004, 17.5), (0.004, 30)}$ . Consequently, for epsilon-optimality on each task, a rough estimate of the number of policies required is $N^{π} = 8$ , for a theoretical task capacity of $C = N_{τ} / N_{π} = 3.4$ .
5.3. Empirical task capacity

A near-optimal set of policies may not necessarily be found, even if it is possible to represent them. The theoretical task capacity ignores various learnability issues within the hypothesis class $H$ , such as (i) the expressive efficiency which implies higher capacity methods require more data [13,63]; (ii) the exploration technique providing representative samples; (iii) the inductive bias of the optimisation (e.g. gradient-descent methods [54] cannot easily escape local optima in non-convex landscapes); and (iv) the effects of learning without convergence and updates cancelling each other out. For these reasons, an empirical task capacity is defined that accounts for learnability. In addition to $H$ , $F$ , and ϵ, the empirical task capacity is also dependent on the temporal structure of the environment and the training algorithm of the base-learner. The empirical task capacity is based on a notion of relative epsilon-optimality for a base-learner, where its one-to-one mapping of policies to tasks represents optimality for that base-learner.

Definition. Base-learners with high empirical task capacity are those for which a low number of policies results in a performance close to, or even better than, a one-to-one mapping of tasks to policies. The empirical task capacity $C_{emp}$ is defined in Equation (3), $\begin{matrix} (3) & C_{emp} = N_{τ} / N_{π}^{*}, \end{matrix}$ where $N_{τ}$ is the total number of tasks and $N_{π}^{*}$ is the lowest number of policies that yields $\begin{matrix} (4) & R ⩾ (1 - ϵ_{c}) R^{1-to-1}, \end{matrix}$ where $R^{1-to-1}$ is the lifetime average performance of the one-to-one mapping with task-specific policies. Learners with high $C_{emp}$ and lower $ϵ_{c}$ can solve on average a number of $C_{emp}$ tasks with a regret of at most $ϵ_{c}$ percentage of $R^{1-to-1}$ .

The choice of $ϵ_{c}$ is ultimately up to the end-user, based on the trade-off between resources used and performance. However, to provide a complete evaluation of a base-learner, as a benchmarking tool, Equation (5) defines the Integrated Task Capacity (ITC), $\begin{matrix} (5) & ITC = \int_{0}^{1} C_{emp} (ϵ_{c}) d ϵ_{c}, \end{matrix}$ which integrates the task capacity over the possible values of $ϵ_{c} \in [0, 1]$ .

Suggested usage. The empirical task capacity is proposed for two use cases. First, it can be used to compare base-learners over a domain and observe which base-learner scales best over tasks. Second, it can be used, analogous to the theoretical task capacity, as a tool for pre-selecting the number of policies. In this case, the user selects a task sequence that represents the application of interest and then estimates the optimal number of policies.

6. Experiment setup

6.1. Base-learners

Two base-learners, Deep Q-Network and Proximal Policy Optimisation, are compared in the study. They represent two classes of state-of-the-art deep RL methods, value-based learners and actor-critic learners. In both cases, a single actor is chosen instead of distributed RL with many actors, because in a realistic, continual lifelong learning setting the learners are not able to perfectly simulate copies of their environment. Their architectures are chosen to be as similar as possible, as depicted in Fig. 2.

Fig. 2.

Architectures used in the experiments. The observation $o_{t}$ at time t is input to a feedforward layer with RELU activations, which is further processed by an LSTM layer with tanh activations, and then further processed by a linear layer which outputs the $Q (o_{t}, a)$ for all $a \in A$ . A single arrow represents connections between each unit in the outgoing layer and each unit in the subsequent incoming layer. For MDP tasks, the LSTM layer is replaced by a second dense RELU layer, also of 80 neurons.

Deep (recurrent) Q-network. For MDP tasks, we investigate Deep Q-Network [46], a state-of-the-art value-based reinforcement learner suitable for discrete action spaces and complex state spaces, as is the case for example in Atari game environments. Its policy depends on a state-action value, and its updates are done in an off-policy style, allowing the training to be independent of the current policy and to repeat events in the distant past. For POMDP tasks, Deep Recurrent Q-Network (DRQN) is chosen due to its track record in partially observable video games [10,23,36,61]. DRQN extends Deep Q-Network with a different experience replay method that samples traces of observations rather than a single observation. This allows it to learn from sequences of observations with a Long Short-Term Memory [26] layer, making it suitable for partially observable environments. A key question in both learners is whether negative transfer results in DQN-based, and other Q-learning-based lifelong learning systems [34,40], can be replicated in other types of tasks and whether these results also hold for DRQN.

DQN repeatedly performs control cycles in which first it outputs for each action its Q-value, $Q (s, a)$ and then selects an action based on these Q-values. To select an action, ϵ-greedy is used, such that with probability $1 - ϵ$ the action with the highest Q-value, $a^{*} = arg {max}_{a \in A} Q (s, a)$ , is taken while with probability ϵ a random action is taken. Then periodically, updates are performed using experience replay. In DQN, updates are based on Q-learning [74] and the loss function is defined in Equation (6), $\begin{matrix} (6) & L (θ) = E_{(s, a, r, s^{'}) \sim U (B)} [{(r + γ max_{a^{'}} Q (s^{'}, a^{'}; \hat{θ}) - Q (s, a; θ))}^{2}], \end{matrix}$ where experience tuples $(s, a, r, s^{'})$ of state, action, reward and next state, are sampled uniformly from a buffer $B$ , and where a factor γ discounts future rewards. The policy’s parameters are θ, which are updated frequently, whilst another set of policy parameters $\hat{θ}$ are synchronised infrequently on a periodic basis to match the policy’s parameters and are used as the target for the neural network.

For initialising DRQN, burn-in initialisation [31] is chosen, where the agent selects a number of random actions to initialise the trace of the recurrent network; for DQN this step is not taken. In DRQN, the updates and the loss function are the same as in DQN except that the sampled states are traces of observations which are passed through an LSTM layer such that the system remembers previous time steps.

In the present paper’s experiments, the buffer of D(R)QN is treated as part of the policy, and therefore each policy will have a separate experience buffer; this ensures that experiences are sampled only from the subset of tasks on which the policy specialises. The convolutional layers are replaced by a single densely connected layer due to the small observation without spatial correlations. Further details of its implementation, including the hyper-parameters, are given in Appendix A.

Proximal policy optimisation with/without LSTM network. Proximal Policy Optimisation (PPO) [60] is a policy optimisation algorithm which is often applied as an actor-critic reinforcement learner. PPO is chosen because of its robustness and transfer learning benefits [9,24,49]. It applies a clipped loss function, shown in Equation (7), that takes into account that the policy updates should not be too large, to allow monotonic improvements, $\begin{matrix} (7) & L (θ) = min (g_{t} {\hat{A}}_{t}, clip (g_{t}; 1 - ϵ, 1 + ϵ) {\hat{A}}_{t}), \end{matrix}$ where ${\hat{A}}_{t}$ is the advantage estimated at time t by Generalised Advantage Estimation [59], $g_{t} = π (a_{t} | o_{t}, θ) / π (a_{t} | o_{t}, θ_{old})$ is the ratio of the probability of the chosen action $a_{t}$ according to the new parameters θ and the old parameters $θ_{old}$ , and $clip (x; y, z)$ clips the number x to the interval $[y, z]$ . This method is applied in an actor-critic style, in which a critic learns the value of a given observation according to $V (o_{t}) = E [\sum_{i = 0}^{\infty} γ^{i} r_{t + i}]$ , with $r_{t}$ the reward at time t, and in which the actor learns $π (a_{t} | o_{t}, θ)$ , the probability of the chosen action in the observation $o_{t}$ , based on the current policy parameters θ.

Analogous to the D(R)QN setting, for POMDP tasks the neural network architecture is supplemented with a Long Short-Term Memory layer [26] and burn-in initialisation [31] is the chosen initialisation at the start of the episode. The architecture differs from DRQN in the sense that there are two output layers, one for the actor and one for the critic, that share their connections to the LSTM layer. The actor’s output, $π (a | s) \forall a \in A$ , provides a probabilistic policy over actions which is directly used for action selection. Further details of its implementation, including the hyper-parameters, are given in Appendix A.

6.2. Learning metrics

To assess forgetting and transfer, we now construct a forgetting ratio and a transfer ratio, which define forgetting by a negative forgetting ratio and negative transfer using a negative transfer ratio. The ratios are similar to transfer learning metrics and are directly based on the performance after transitioning from earlier tasks to the task of interest [5,65], and in particular, the area ratio [65], which compares the performance of a policy with experience on other tasks to a policy that is randomly initialised. Like the area ratio, our metrics integrate the performance across the entire task-block to capture the complete learning behaviour, contrasting to jumpstart, time to threshold, and asymptotic performance. Due to the existence of many task-blocks of the same task, the proposed transfer and forgetting ratios are first computed for all task-block transitions across the lifetime. Forgetting ratios are then aggregated for different bins of the number of interfering task-blocks while transfer ratios are aggregated for different bins of the number of prior task-blocks.

The forgetting ratio is defined in Equation (8) as $\begin{matrix} (8) & forgetting ratio = \frac{Δ - Δ^{1-to-1}}{area-uniform-random}, \end{matrix}$ where $Δ = area-after - area-before$ is the improvement in performance area under the curve comparing the performance on the current task-block to that of the prior task-block of the same task, $Δ^{1-to-1}$ is the analogous improvement for the 1-to-1 policy selection, and area-uniform-random is the performance area under the curve for a uniform random policy, i.e. a policy that selects actions randomly from the action set.

The transfer ratio is defined in Equation (9) as $\begin{matrix} (9) & transfer ratio = \frac{area-after - 1-to-1-area}{area-uniform-random}, \end{matrix}$ where area-after, or area-with-transfer, is the performance area under the curve for the current task-block and 1-to-1-area is the performance area under the curve for the 1-to-1 policy. The 1-to-1 policy performance on the task-block is equal to the area-without-transfer used in the area ratio since the transfer ratio is only computed for the first presentation of the target task.

The transfer ratio differs from the area ratio in the use of the uniform random policy performance as the denominator; this compares different base-learners in the same units and avoids the sensitivity to scale mentioned in [65]. The forgetting ratio also is formulated using the uniform random policy in the denominator; dividing by the uniform random policy as opposed to the performance of the base-learner on a previous block avoids sequential effects (e.g. consequent task-blocks after a completely forgotten task could potentially have a performance near zero, giving a high score and dominating the aggregated forgetting ratio). The correction for the 1-to-1 policy’s improvement $Δ^{1-to-1}$ represents the expected transition improvement with no forgetting rather than the improvement in performance over the previous task-block which is subject to sequential effects; for instance, in late stages of training, only minor improvements in performance can be gained over the previous task-block. After aggregation of task transitions for bins of the number of prior task-blocks, the forgetting ratio determines the effect of interfering task-blocks on performance. The transfer ratio has no sequential effects, as only the first task-block is being assessed for any given task. Therefore, the transfer ratio can also be interpreted as is, without aggregation.

Policy spread. An additional metric, called the policy spread, estimates the variability in the policies during the lifetime. The policy is a function of the parameter space and the observations, and therefore, when different policies are spread widely in parameter space, this does not necessarily imply a wide spread in the policies. Therefore, the variability in the policies is assessed empirically by randomly sampling viable observations and determining the selected action probabilities. In PPO, this is directly based on the output of the actor-network which outputs a probability for each action $a \in A$ . In DRQN, this is based on the ϵ-greedy exploration, which first obtains the action $a_{max} = arg {max}_{a^{'}} Q (o_{t}, a_{t})$ and then assigns the probability $1 - ϵ + ϵ / | A |$ for $a_{max}$ and the probability $ϵ / | A |$ for actions other than $a_{max}$ . The calculation of the spread is based on the total variation distance, a distance metric for probability distributions, applied to all pair-wise combinations of the policies’ action probabilities in an experimental condition.

6.3. Lifelong learning domains

The experimental setup tests the impact of the number of policies on performance, probing in particular the effects of changing reward functions and transition dynamics as these limit the scalability (see Corollary 1 and 2). The experiments are conducted in a 27-task Cartpole MDP domain, in which a feedforward DQN and PPO are used, and an 18-task POcman POMDP domain, in which case an LSTM layer is added for a recurrent version of PPO and DRQN.

These domains are chosen to illustrate the challenge of lifetime policy reuse, involving randomly chosen tasks presented in rapid succession. In both domains, the learner does not have time to converge its parameters, memories of earlier tasks can be lost by the time they are presented again, and policies learned on one task may transfer negatively to other tasks. The differences between these two domains help to analyse critical factors underlying its success: (i) changing reward functions; (ii) changing transition dynamics; (iii) partial observability; and (iv) task similarity. The MDP domain has a relatively large task-similarity and has full observability. The POMDP domain has lower task-similarity and has changes in reward functions, which combined with the partial observability makes it challenging to infer the task from within the policy; this contrasts to Atari and other video games where a single observation is sufficient to recognise the task. Such partial observability is often true in the real world, where opposite policies are often required but this is unknown to the learner due to the effect of hidden variables. Therefore, the POMDP domain allows to assess strategies for lifetime policy reuse in low task-capacity scenarios.

27-task Cartpole MDP domain. In the 27-task Cartpole MDP domain, reinforcement learners are tasked with moving a cart back and forth to balance a pole for as long as possible. The domain includes varying transition dynamics but not varying reward functions. 27 unique tasks are based on varying properties of the cart and the pole: (i) the mass of the cart varies in ${0.5, 1.0, 2.0} kg$ ; (ii) the mass of the pole varies in ${0.05, 0.1, 0.2} kg$ ; and (iii) the length of the pole varies in ${0.5, 1.0, 2.0} m$ . Due to the tasks being relatively similar, this domain represents an optimistic evaluation of task capacity.

The lifetime of the learner starts at $t = 0$ and ends at $t = T$ , where T is chosen to be 40.5 million time steps. At each time step, the learner receives an observation $⟨ x, θ, \dot{x}, \dot{θ} ⟩$ , where x and $\dot{x}$ are the position and velocity of the cart, and θ and $\dot{θ}$ are the angle of the pole to vertical and its rate of change. The learner is equipped with a fixed set of 2 actions, $A = {left, right}$ , moving the cart left or right by applying a force of $- 1 N$ or $+ 1 N$ . The observations and actions follow the Markov property such that $P (o_{t} | o_{t - 1} a_{t - 1} \dots o_{1} a_{t}) = P (o_{t} | o_{t - 1} a_{t - 1})$ . Each time step is rewarded with $+ 1$ but the episode terminates when either the pole has an angle of more than $15^{\circ}$ from vertical or when the distance of the cart to the centre is greater than $2.4 m$ . The episode is also terminated after 200 time steps of balancing as in this case the learner is considered to be successful.

In this experiment, tasks are presented in a random sequence from a uniform random distribution, with each task sequence providing a unique order. To account for the variability in the experiments due to the stochasticity in the actions selected by the reinforcement learner, as well as the random task presentation, the learners are evaluated based on 27 independent runs. Each independent run consists of 40.5 million time steps and corresponds to a unique task sequence. Each task sequence consists of 675 task-blocks. Each task-block consists of 60,000 time steps, or at least 300 episodes, of the same given task. With 27 unique tasks, this allows on average 25 blocks per task. Each episode takes at most 200 time steps, depending on the success of the learner. To minimise the effects of task order, the tasks are spread evenly between the different task sequences, as is illustrated in Fig. 3.

Fig. 3.

Illustration of the task sequences assuming a number of tasks $N_{τ} = 18$ . To form the zeroth task sequence, task indices are sampled randomly in ${0, 1, \dots, N_{τ} - 1}$ for each successive task-block. To form the n’th task sequence, where $n > 0$ , the task index is chosen for each task-block as $j = (i + n) mod N_{τ}$ , where i is the task index in the zeroth task-sequence. Thus all tasks are represented exactly once when taking a vertical slice across sequences at any given time-point; apart from varying the task-order this also facilitates analysis due to a smooth aggregate development curve over time. $N_{τ} = 18$ represents the 18-task POcman POMDP domain. For the 27-task Cartpole MDP domain, the above illustration applies after setting $N_{τ} = 27$ .

18-task POcman POMDP domain. In the 18-task POcman POMDP domain, reinforcement learners interact with 18 tasks each of which contains an object of interest and has an unknown grid-world topology. While the smaller state space reduces the number experiences required, the lifelong learning domain is extremely challenging due to including varying transition dynamics, varying reward functions, and partial observability.

As illustrated in Fig. 4, the environment’s 18 distinct tasks are based on three dimensions, $(R, M, T)$ , where: $R \in {- 1 ., 1 .}$ is the reward for touching the main object in the task; $M \in {0, 1, 2}$ is a dimension specifying the movement of the object of interest, with 0 indicating static, 1 indicating a random step (north, east, south or west) once every 20 time steps, and 2 indicating a strategy which reacts each time step to the RL agent, by moving away defensively in case $R = 1$ ., or by aggressively moving towards the agent in case $R = - 1$ ;1

The defensive strategy is to move away with a 50% probability and otherwise to stand still, and the aggressive strategy is to move towards the agent with a 50% probability and otherwise to take a random action.

T \in {0, 1, 2}

is the grid-world topology corresponding to the cheese-maze [45], Sutton’s maze as mentioned in [58], and a 9-by-9 version of the partially observable pacman (POcman) [72]. When the object is static, the learner must find the location with the object, if

R = 1

, or without the object, if

R = - 1

. When the object is dynamic, the learner should either follow the object as closely as possible, if

R = 1

, or stay away at a safe distance, if

R = - 1

. Objects are never removed even when the agent touches, allowing more frequent contact between the agent and the object and the corresponding rewards until the elementary task ends. To ensure a certain difficulty level and emphasise a searching strategy rather than simple goal achievement, the initial coordinates of the object of interest are not fixed over time, but are randomly chosen from a set of

(x, y)

-coordinates; see Appendix A for starting coordinates.

Fig. 4.

Illustration of POcman tasks based on three defining task characteristics. (a) in a positive dynamic task, the learner must touch the defensively moving ghost; (b) in a negative dynamic task, the learner must avoid the aggressively moving ghost; (c) in a positive static task, the learner must touch the food pellet; (d) in a negative static task, the learner must avoid touching the poison bottle. Note that the objects are illustrated in this way purely for interpretation, whereas the learner perceives the objects as the same observation on all tasks.

The lifetime of the learner starts at $t = 0$ and ends at $t = T$ , where T is 90 million time steps. The learner’s actions are $A = {north, east, south, west, stay}$ . Observations are 11-bit vectors similar to those in POcman [72]: the first four indicate for each cell in a Von Neumann-neighbourhood whether it contains an obstacle or not; the next four indicate for each cell in a Von Neumann-neighbourhood whether it contains the object of interest; and the final three bits indicate whether or not the object is within a Manhattan distance of 2, 3 or 4 steps from the learner. There are no terminal states but the episode ends after 1000 time steps, after which the learner is reset to the starting location. In the first 15 time steps after being reset, any external action is chosen randomly by the learner to allow the learner to form an initial trace of observations for its policy.

As in the MDP task sequences, tasks are presented in a random sequence from a uniform random distribution and each task sequence provides a unique order. Independent runs account for the stochasticity in the learner and environment and task order effects are minimised by spreading tasks evenly between the different task sequences. In the POMDP domain, each task sequence consists of 450 task-blocks with 200 episodes of the same given task.

6.4. Experimental conditions and analyses

To demonstrate the proposed approach, a first study compares the performance of Lifetime Policy Reuse across different settings of the number of policies as well as an ablation without the adaptive policy selector. For the unadaptive policy selector, the policy is selected based on a fixed, balanced partitioning of tasks. For unadaptive mappings, the experiments manipulate the number of policies $N_{π} \in {1, 2, 4, 9, 14, 27}$ in the 27-task MDP domain and $N_{π} \in {1, 2, 4, 9, 18}$ in the 18-task POMDP domain. The adaptive policy selection conditions are the same, except that the 1-to-1 policy selection and the 1-policy condition are removed as adaptivity is not useful in these cases.

The above-mentioned conditions are abbreviated based on three properties: (i) adaptivity, either Adaptive or Unadaptive; (ii) the base-learner, either P(R)PO or D(R)QN, where PRPO is used to indicate a PPO learner with LSTM policy; and (iii) the number of policies followed by P. For instance, AdaptivePPO14P indicates a 14-policy PPO learner with adaptive policy selection.

The performance evaluation experiments are conducted on the IRIDIS4 supercomputer [70] using a single Intel Xeon E5-2670 CPU (2.60 GHz) with a varying upper limit to RAM proportional to the number of policies (approximately $2 N_{π} GB$ ). Each run lasts for 2 days for the 27-task MDP domain and 6-9 days for the 18-task POMDP domain. The code for the experiments is available at https://github.com/bossdm/LifelongRL.

After the performance demonstration, a further analysis then investigates three hypotheses to support the understanding of the Lifetime Policy Reuse and the importance of task capacity.

The first hypothesis is that adaptivity in the policy selection is beneficial if a particular policy is situated in a bad region of parameter space, in which case selecting one of the alternative policies may rapidly find a favourable location of the parameter space. This hypothesis is assessed by making use of the policy spread of learners and relating it to the performance benefit of adaptivity (if any).

The second hypothesis is that task capacity pre-selection is important in the sense that it can be used together with Lifetime Policy Reuse with the following benefits: a) it improves performance and learning; b) it reduces the memory cost; and c) it generalises towards related task spaces. While aspect a) is assessed based on the performance evaluation and the corresponding learning metrics, aspect b) and c) require additional experiments. To assess aspect b), the proposed approach of using a fixed policy library is compared to the growing policy library used in traditional policy reuse methods across different settings of the task capacity, the probability of accepting a policy into the policy library, and the number of task-blocks until convergence. To assess aspect c), additional experiments are conducted on a 125-task Cartpole MDP domain which is based on the same three task-features within the same range as the 27-task domain but with more values included per task-feature.

The third hypothesis is that PPO and DQN are subject to the same representational limits of the theoretical task capacity but due to the more aggressive updates, DQN will push these limits more rapidly; thereby learning more rapidly but also forgetting more rapidly. Additional experiments on the 27-task Cartpole domain investigate the effect of increasing task-block sizes and relaxing the clipped objective as evidence for the hypothesis. To rule out an alternative hypotheses, experiments with alternative experience replay methods are conducted, including modifying the replay buffer through distribution matching, task-matching, and larger buffer sizes.

Fig. 5.

Performance evaluation of lifetime policy reuse compared to single-policy and 1-to-1 policy baselines. a) results for the 27-task Cartpole domain, plotting the average score (mean ± standard error) across 25 consecutive task-blocks, or every 1,500,000 time steps, as a function of the number of time steps. b) results for the 18-task POcman domain, plotting the cumulative reward as a function of the number of time steps. The number of policies for lifetime policy reuse is set based on the best available task capacity metric, namely: in the Cartpole domain, $N_{π} = 9$ for PPO and DQN based on the theoretical task capacity; in the POcman domain, $N_{π} = 9$ for DRQN and $N_{π} = 2$ for PPO based on the empirical task capacity with $ϵ_{c} = 0.30$ .

Fig. 6.

Average score (mean ± standard error) in the 27-task Cartpole MDP domain for different multi-policy variants of the DQN and PPO base-learners. “Ours” indicates the proposed lifetime policy reuse algorithm with its ϵ-greedy policy selection and a number of policies indicated by the task capacity. To demonstrate the importance of selecting a suitable number of policies and the effectiveness of the ϵ-greedy policy selector, the number of policies is manipulated and the ϵ-greedy policy selector is compared to a fixed policy selector which balances task assignments equally across policies. The inclusion vs exclusion of ϵ-greedy is indicated by adaptive vs unadaptive while the number of policies is indicated by the suffix (e.g. 4P for 4 policies). The average score is averaged every 25 consecutive task-blocks, or every 1,500,000 time steps.

7. Performance evaluation and analysis

Having defined the experimental conditions, this section provides the experimental results, including the performance evaluation for the 27-task Cartpole and 18-task POcman as well as a further analysis. Before providing detailed results with ablations and parametric studies, Fig. 5 provides an initial demonstration of the effectiveness of Lifetime Policy Reuse: despite using significantly fewer policies, Lifetime Policy Reuse provides comparable performance levels to the 1-to-1 policy setting for both DQN and PPO base-learners.

7.1. 27-task Cartpole MDP domain

The development of the average score in the 27-task Cartpole MDP domain is shown in Fig. 6 for different settings of the number of policies. The following main trends are observed:

For DQN, settings of the number of policies $N_{π} ⩾ 9$ confer a stable upward curve over time, while settings $N_{π} ⩽ 4$ demonstrate a rapid increase at first but then have degrading performance over time. With the optimal performance being 200, settings of $N_{π} ⩾ 9$ converge to an optimal or near-optimal performance, accounting for the need for exploratory actions.

For PPO, settings of the number of policies $N_{π} ⩾ 4$ confer a stable upward curve over time towards a high but suboptimal performance between 75 and 100; within this group of settings, $N_{π} = 27$ reaches a similar final performance but is considerably slower to converge. Settings $N_{π} ⩽ 2$ demonstrate a degrading performance over time, although the effects are much less pronounced compared to DRQN.

Overall DQN demonstrates rapid and pronounced performance improvements while PPO learns more slowly but more stably.

Adaptivity has a small negative effect on the performance.

The average and final performances are summarised in Table 1. For DQN, the best performances are reached by 14- and 27-policy settings, with an average lifetime performance of around 150 and a final performance of 170–180. The 1-to-1 27-policy significantly outperforms the conditions where

N_{π} ⩽ 2

²
All significance values reported in this paper are based on pair-wise F-tests between the conditions, and $p < 0.01$ is considered as statistically significant.

However, UnadaptiveDQN4P and settings of 9 or 14 policies, except the AdaptiveDQN14P (

p = 0.994

), significantly outperform the 1-to-1 27-policy learner. For PPO, all the Unadaptive conditions outperform the 1-to-1 27-policy learner; this effect is significant for all Unadaptive conditions except UnadaptivePPO1P, but not significant for Adaptive conditions (p ranging from 1.0 for

N_{π} = 2

to 0.02 for

N_{π} = 14

). PPO’s 1-policy approach performs lower than the 1-to-1 policy but not significantly so (

p = 0.763

Table 1

Performance in the 27-task Cartpole MDP domain as a function of the number of policies and the inclusion of adaptivity with the ϵ-greedy policy selection. The lifetime average score, and the final score, averaged across the last 10 task-blocks, or the last 600,000 time steps, are shown as the mean ± standard-deviation across the 27 independent runs. “Ours” indicates the proposed lifetime policy reuse algorithm with its ϵ-greedy policy selection and a number of policies indicated by the task capacity. Scores are sampled once every 60,000 time steps

Performance

(a)	DQN			(b)	PPO

	Method	lifetime	final		Method	lifetime	final
	AdaptiveDQN2P	$109.2 \pm 31.9$	$34.7 \pm 41.4$		AdaptivePPO2P	$68.6 \pm 6.6$	$55.5 \pm 28.4$
	AdaptiveDQN4P	$147.5 \pm 16.1$	$121.3 \pm 35.6$		AdaptivePPO4P	$72.5 \pm 9.6$	$71.0 \pm 23.4$
	AdaptiveDQN9P (ours)	$153.9 \pm 7.5$	$163.7 \pm 21.8$		AdaptivePPO9P (ours)	$72.9 \pm 7.7$	$73.5 \pm 23.2$
	AdaptiveDQN14P	$147.9 \pm 5.6$	$169.7 \pm 14.6$		AdaptivePPO14P	$72.1 \pm 4.7$	$80.1 \pm 13.7$
	UnadaptiveDQN1P	$71.8 \pm 35.9$	$25.1 \pm 44.1$		UnadaptivePPO1P	$67.7 \pm 9.1$	$58.4 \pm 38.8$
	UnadaptiveDQN2P	$118.8 \pm 31.1$	$56.2 \pm 47.6$		UnadaptivePPO2P	$78.1 \pm 9.9$	$63.5 \pm 31.8$
	UnadaptiveDQN4P	$156.2 \pm 9.3$	$123.2 \pm 35.3$		UnadaptivePPO4P	$80.2 \pm 6.0$	$77.1 \pm 26.5$
	UnadaptiveDQN9P	$161.5 \pm 3.3$	$176.0 \pm 12.7$		UnadaptivePPO9P	$80.5 \pm 4.3$	$84.1 \pm 21.0$
	UnadaptiveDQN14P	$155.8 \pm 2.8$	$179.5 \pm 9.3$		UnadaptivePPO14P	$75.5 \pm 4.2$	$90.5 \pm 19.0$
	UnadaptiveDQN27P	$147.9 \pm 2.6$	$179.5 \pm 8.4$		UnadaptivePPO27P	$68.5 \pm 2.6$	$84.5 \pm 11.6$

Fig. 7.

Cumulative reward (mean ± standard error) in the 18-task POcman POMDP for different multi-policy variants of the DQN and PPO base-learners. “Ours” indicates the proposed lifetime policy reuse algorithm with its ϵ-greedy policy selection and a number of policies indicated by the task capacity. To demonstrate the importance of selecting a suitable number of policies and the effectiveness of the ϵ-greedy policy selector, the number of policies is manipulated and the ϵ-greedy policy selector is compared to a fixed policy selector which balances task assignments equally across policies. The inclusion vs exclusion of ϵ-greedy is indicated by adaptive vs unadaptive while the number of policies is indicated by the suffix (e.g. 4P for 4 policies).

7.2. 18-task POcman POMDP domain

The development of the cumulative reward in the 18-task POMDP POcman domain is shown in Fig. 7 for different settings of the number of policies. Two differences with the 27-task MDP domain are the positive effect of adaptivity and the 1-to-1 policy being much higher-performing than settings with 2 or 3 tasks per policy. However, the other trends are comparable to the previous domain:

The cumulative reward intake improves as the number of policies is increased, with the 18-policy algorithm performing best in both DRQN and PPO.

For DRQN, increasing the number of policies substantially increases the performance and the single policy’s performance even decreases over time.

For PPO, all learners are able to improve over the lifetime and the differences between conditions are less pronounced than for DRQN; PPO’s single policy performance is better but its multi-policy is worse than the corresponding DRQN condition.

DRQN’s best-performing setting, here $N_{π} = 18$ , is close to the optimal performance, here 45 million in lifetime cumulative reward, considering the need for exploratory actions.3

³
An upper bound for the optimal performance is achieving a reward of 1 in tasks with $R = 1$ and a reward of 0 in tasks with $reward = - 1$ . With tasks being equally split in $R \in {- 1, 1}$ , this implies for a lifetime of 90 million steps that the theoretical upper bound on the lifetime cumulative reward is 45 million.

The average and final performances are summarised in Table 2. For DRQN, the single policy has a lifetime average performance of 0.016, and including multiple policies improves the lifetime average performance monotonically with increasing number of policies, with a factor ranging between 3, for the unadaptive 2-policy learner with its performance of 0.049, and 20, for the 18-policy learner with its performance of 0.309. All learners with multiple policies, including both adaptive and unadaptive conditions and all settings of $N_{π} \in {2, 4, 9, 18}$ , are able to improve on the lifetime average performance with significant effects. A higher number of policies is also beneficial for PPO but it has a smaller effect: all conditions have a performance ranging between 0.60-0.90, which is 1–1.5 times the performance of the single policy condition, even though some effects are significant (e.g. compare unadaptive policy selection with high versus low number of policies). The single policy PPO has four times the lifetime average performance of the single policy DRQN but multi-policy DRQN conditions have 2–3 times the lifetime average performance of multi-policy PPO conditions.

Table 2

Performance (mean ± standard-deviation) in the 18-task POcman POMDP domain as a function of the number of policies and the inclusion of adaptivity with the ϵ-greedy policy selection. Two performance metrics, based on the cumulative reward function $R (t) = \sum_{τ = 0}^{t} r_{τ}$ , are shown as the mean ± standard-deviation across the 18 independent runs: the lifetime average reward, defined as $R (T) / T$ , where $T = 9 * 10^{7}$ is the total lifetime of the learner; and the final average reward, defined as $\frac{R (T) - R (T - t)}{t}$ , where $T = 9 * 10^{7}$ and $t = 2 * 10^{6}$ . “Ours” indicates the proposed lifetime policy reuse algorithm with its ϵ-greedy policy selection and a number of policies indicated by the task capacity

Performance

(a)	DRQN			(b)	PPO

	Method	lifetime	final		Method	lifetime	final
	AdaptiveDRQN2P	$0.098 \pm 0.017$	$0.104 \pm 0.092$		AdaptivePRPO2P (ours)	$0.062 \pm 0.012$	$0.055 \pm 0.081$
	AdaptiveDRQN4P	$0.154 \pm 0.027$	$0.160 \pm 0.104$		AdaptivePRPO4P	$0.065 \pm 0.011$	$0.070 \pm 0.098$
	AdaptiveDRQN9P (ours)	$0.200 \pm 0.025$	$0.221 \pm 0.105$		AdaptivePRPO9P	$0.072 \pm 0.017$	$0.070 \pm 0.088$
	UnadaptiveDRQN1P	$0.016 \pm 0.007$	$0.002 \pm 0.054$		UnadaptivePRPO1P	$0.057 \pm 0.011$	$0.055 \pm 0.090$
	UnadaptiveDRQN2P	$0.049 \pm 0.017$	$0.072 \pm 0.104$		UnadaptivePRPO2P	$0.063 \pm 0.013$	$0.071 \pm 0.094$
	UnadaptiveDRQN4P	$0.105 \pm 0.029$	$0.098 \pm 0.108$		UnadaptivePRPO4P	$0.081 \pm 0.017$	$0.082 \pm 0.093$
	UnadaptiveDRQN9P	$0.220 \pm 0.028$	$0.236 \pm 0.135$		UnadaptivePRPO9P	$0.086 \pm 0.018$	$0.084 \pm 0.116$
	UnadaptiveDRQN18P	$0.309 \pm 0.021$	$0.323 \pm 0.124$		UnadaptivePRPO18P	$0.088 \pm 0.015$	$0.107 \pm 0.096$

The final performance yields results similar to the lifetime average, with two notable exceptions. First, the variability is much higher, resulting in higher p-values and a lower confidence in the results. Second, the single policy approach in DRQN deteriorates strongly, down to 0.002, despite the other final performances being in the range of 0.072, for the unadaptive 2-policy, to 0.323, for the 18-policy DRQN approach. This means that the improvement obtained by including multiple policies is between 35 and 133 times in performance. By contrast, the single policy approach for PPO has not deteriorated and scores similarly to its lifetime average, 0.055.

With 2–4 policies, adaptive DRQN significantly outperforms unadaptive DRQN; however, with 9 policies, there is no significant difference. Adaptivity can have a beneficial effect comparable to increasing the number of policies: although comparisons of a larger to a smaller setting of $N_{π}$ are significant, the AdaptiveDRQN2P, with its lifetime average of 0.098, does not show a significant difference to the UnadaptiveDRQN4P, with its lifetime average of 0.105 ( $p = 0.532$ ); similarly, for the final performance, AdaptiveDRQN4P is not significantly different from UnadaptiveDRQN2P whereas UnadaptiveDRQN4P vs UnadaptiveDRQN9P does give a significant difference.

7.3. Analysis

This section further analyses three core hypotheses to explain the above results, illustrating Lifetime Policy Reuse and the importance of task capacity.

Hypothesis 1: Adaptive policy selection provides escape from low-performing regions of parameter space. The first hypothesis is that adaptivity in the policy selection is beneficial if a particular policy is situated in a bad region of parameter space, in which case selecting one of the alternative policies may rapidly find a favourable location of the parameter space. Due to the positive effect of adaptivity only occurring in the DRQN conditions in the 18-task POMDP domain, this hypothesis is supported empirically if DRQN has a higher policy spread than PPO in the 18-task POMDP domain, but not in the 27-task MDP domain. Empirical results support the hypothesis: in the 18-task POMDP domain, adaptive DRQN conditions have a policy spread within $[0.6, 0.7]$ while PPO has a policy spread within $[0.1, 0.3]$ (see Fig. 8); in the 27-task MDP domain, adaptive DRQN conditions have a policy spread within $[0.3, 0.4]$ while PPO has a policy spread within $[0.4, 0.45]$ . Comparing the two domains, the 18-task POMDP domain, which has opposing dynamics such as approach and avoid behaviours, may have a lower task-similarity compared to the 27-task MDP domain, which has more behavioural constants such as moving in the direction to which the pole tilts; this implies the required policies for 18-task POMDP are highly distinct, and continuing to train an initially unsuccessful policy will be less efficient than switching policy.

Fig. 8.

Policy spread (mean ± standard error) in the 18-task POcman POMDP, representing the average variability between the stochastic policies in the policy library. The different base-learners are compared, showing that PPO has more limited variability in its policies compared to DRQN, explaining why DRQN gains more performance from adaptive policy selection.

Hypothesis 2: The importance of task capacity. The importance of task capacity is now demonstrated on three metrics, showing that task capacity pre-selection a) improves performance and learning metrics; b) reduces the memory cost; and c) generalises towards related task spaces, such that the same number of policies can be used with the same performance benefits. To this end, the analysis below compares settings of the number of policies above task capacity to settings below task capacity.

a) Improved performance and learning metrics: In the Cartpole domain, the theoretical task capacity for deep reinforcement learners has been estimated as $C = 3.4$ (see final paragraphs of Section 5.2), corresponding to a minimum of required policies $N^{π} = 8$ . The following benefits of pre-selection, using $N_{π} = 9$ just above the requirement, are found for DQN:

Improved performance: with 9 or more policies, the performance converges to the highest level for the base-learner; with 1-, 2-, and 4-policy learners, a degrading performance is observed towards the end of the run. These findings are consistent with the hypothesis from the theoretical task capacity that the representational limit of the policies is being exceeded.

Improved DQN forgetting ratio: with 9 or more DQN policies, the forgetting ratio is near-zero; with 1-, 2-, and 4-policy DQN learners have a degrading forgetting ratio between $- 0.5$ and $- 1$ as more interfering task-blocks are presented, with $- 1$ for the 1-policy DQN for 30 or more interfering task-blocks. This is consistent with forgetting being primarily due to representational overlap.

Marginally improved PPO forgetting ratio: for PPO, similar trends are demonstrated except that the differences are much smaller.

A further observation is that while DQN displays a higher transfer ratio than PPO for low-policy settings, this effect does not improve performance because it is negated by DQN’s stronger forgetting. In the POcman domain, a theoretical task capacity estimate is not available; however, it can be observed that the empirical task capacity is lower (

C_{emp} = 4.5

for PPO and

C_{emp} = 2

for DRQN) and strong forgetting and negative transfer trends are observed. Additional analyses of empirical task capacity can be found in Appendix B.

b) Reduced memory cost: The analysis of memory cost considers the growth of the number of policies as a function of (i) the task capacity; (ii) the number of task-blocks until convergence; and (iii) and the acceptance probability, defined as the probability that newly proposed policies are accepted into the policy library. The analysis fixes the number of tasks to $N_{τ} = 1000$ and makes a few simplifying assumptions, namely that the acceptance probability is fixed and that the number of policies required is equal to that in lifetime policy reuse. Figure 11 in Appendix B demonstrates that a higher task capacity, a larger number of task-blocks until convergence, and a higher acceptance probability are associated with larger increases in RAM when comparing traditional policy reuse to fixing the number of policies to the task capacity. Even though the maxima chosen, namely task capacity $C = 5$ and task-blocks $T_{c} = 4$ , are still relatively low, the increase is between three- and five-fold, depending on how frequently new policies are accepted in the library. Due to the larger number of task-blocks until convergence, traditional policy reuse will store the temporary policy for one task while learning another task, whereas Lifetime Policy Reuse can maintain the fixed number of policies given by the task capacity.

c) Generalisation to 125-task domain The hypothesis that the pre-selected number of policies generalises across related tasks spaces is investigated below by an empirical demonstration on a 125-task Cartpole MDP domain. The domain has the same three task-features within the same range as the 27-task domain but with more values included per task-feature. That is, (i) the mass of the cart varies in ${0.5, 0.75, 1.0, 1.5, 2.0} kg$ ; (ii) the mass of the pole varies in ${0.05, 0.075, 0.1, 0.15, 0.2} kg$ ; and (iii) the length of the pole varies in ${0.5, 0.75, 1.0, 1.5, 2.0} m$ . The results for DQN and PPO confirm the above hypothesis. First, similar to the demonstration for the theoretical task capacity, the same performance trends are observed (see Fig. 9), with 9 policies being sufficient for a smooth upward and converging curve and 4 or fewer policies appearing to induce representational overlap. Second, for $ϵ_{c} = 0.05$ as in the empirical task capacity results in Appendix B, the relative $ϵ_{c}$ -optimality of the lifetime average performance with respect to the 27-policy learner is provided for both base-learners by the same setting as in the 27-task domain: for DQN, this is a setting of 4 or more policies, as the performance is $80.3 \pm 21.7$ for 1 policy, $116.3 \pm 26.8$ for 2 policies, $154.8 \pm 8.9$ for 4 policies, $158.0 \pm 3.6$ for 9 policies, $147.5 \pm 3.2$ for 14 policies, and $128.4 \pm 3.2$ for 27 policies; for PPO, this is a setting of 1 or more policies, as the performance is $67.0 \pm 8.0$ for 1 policy, $80.6 \pm 7.9$ for 2 policies, $81.4 \pm 5.7$ for 4 policies, $78.6 \pm 3.8$ for 9 policies, $76.8 \pm 3.3$ for 14 policies, and $68.6 \pm 2.5$ for 27 policies.

Hypothesis 3: DQN and PPO performance difference explained by unbounded updates vs monotonic improvement. A third and last hypothesis is that the performance results are explained by the difference between unbounded updates of DQN compared to the clipped updates of PPO for monotonic improvement. That is, PPO and DQN are subject to the same representational limits of the theoretical task capacity but due to the more aggressive updates, DQN will push these limits more rapidly. The empirical results (see section on DQN vs PPO in Appendix B) are consistent with the hypothesis. First, increasing task-block sizes and relaxing the clipped objective demonstrates that the monotonic improvement objective of PPO slows down the learning progress on a single task but helps to maintain performance across many sequentially presented tasks. Second, modifying the replay buffer, through distribution matching, task-matching, and larger buffer sizes, does not reduce DQN’s forgetting metrics, thereby ruling out an alternative hypothesis.

Average score (Mean ± Standard Error) in the 27-task Cartpole MDP domain for different multi-policy variants of the DQN and PPO base-learners. “ours” indicates the proposed Lifetime Policy Reuse algorithm with its ϵ-greedy policy selection and a number of policies indicated by the task capacity. To demonstrate the importance of selecting a suitable number of policies and the effectiveness of the ϵ-greedy policy selector, the number of policies is manipulated and the ϵ-greedy policy selector is compared to a fixed policy selector which balances task assignments equally across policies. The inclusion vs exclusion of ϵ-greedy is indicated by Adaptive vs Unadaptive while the number of policies is indicated by the suffix (e.g. 4P for 4 policies). The average score is averaged every 25 consecutive task-blocks, or every 1,500,000 time steps.

Fig. 9.

Average score (mean ± standard error) in the 125-task Cartpole MDP domain for different multi-policy variants of the DQN and PPO base-learners. The pre-selected number of policies, as indicated by 9P for 9 policies and the “pre-selected” suffix, is among the top performers across different settings of the number of policies, indicating that one can set the number of policies based on smaller but related task domains. The average score is averaged every 25 consecutive task-blocks, or every 1,500,000 time steps.

8. Discussion

This paper presents an approach to policy reuse that scales to lifetime usage, in the sense that (a) its number of policies is fixed and does not result in memory issues; (b) its evaluation is based on the lifetime average performance; and (c) its policies are continually refined based on the lifetime of experience with newly incoming tasks. The approach is widely applicable to MDPs and POMDPs and various base-learners, as is illustrated empirically for DQN and PPO base-learners in cartpole and POcman domains. To help select the number of policies required for a domain, theoretical and empirical task capacity metrics are developed and illustrated for a few examples. These metrics are proposed for three purposes, each of which has been shown in this paper to have empirical support:

To pre-select, based on theoretical arguments, the number of policies required on a task sequence. This purpose has been demonstrated by the observation that violating the task capacity requirement leads to negative transfer and forgetting.

To select the number of policies required for a lengthy task sequence based on a limited but fairly representative task-sequence. This purpose has been demonstrated by the use of the 27-task Cartpole domain to select the number of policies for the 125-task Cartpole domain.

To benchmark base-learners in terms of their scalability. Having a representation of comparable complexity, D(R)QN and PPO are found to have the same theoretical task capacity. However, they demonstrate observable differences in the empirical task capacity metric due to learning and forgetting at different rates.

Lifetime Policy Reuse comes with certain benefits but also certain limitations compared to existing alternatives. Compared to other algorithms, it can be applied when task sequences involve (i) a rapid succession of randomly presented tasks; and (ii) distinct task clusters each of which allow significant positive transfer within clusters and negative transfer between clusters. Compared to traditional policy reuse [16,25,40,42,52,73,79], the lifetime set-up allows online learning without growing the policy library, requiring policies to converge on the task, or modifications to the base-learner’s usual learning algorithm. Lifetime Policy Reuse continually refines its existing policies, overcoming a downside of offline methods for policy reuse (e.g., [52]): since the simulation may not represent the real-world environment or as unexpected problems may come up during the application of interest, no suitable policy will be available in the library. However, a challenge that follows is to avoid catastrophic forgetting; the results in this paper show that this can be avoided through appropriate selection of the number of policies guided by the task capacity. As in other policy reuse methods, Lifetime Policy Reuse avoids task-specific parameters and task-descriptive features (see e.g., [15,43,53]), allowing policies that are uniquely specialised to subsets of tasks and requiring less expert knowledge on the task domain. Lifetime Policy Reuse similar to other policy reuse algorithms and LRL algorithms using task-specific parameters requires that tasks can be identified with a task index. Various LRL algorithms (e.g. [1,8]) focus only on learning a new task from various source tasks rather than also considering the problem of retaining knowledge of prior tasks; as such these do not require a task index but applying them as given would imply relearning any task re-occurring in a long task sequence. The requirement of the task index is not strong, since instead of being provided by the environment it could be identified automatically by the agent using task identification. For example, a Hidden Markov Model can predict the task from observations [34] or an observed change in reward distribution can indicate a new task is being presented [44].

The performance and adaptivity findings in the Cartpole domain and the POcman domain have significance for RL in challenging lifelong learning domains. For the Cartpole domain, learners with one policy for every three tasks can similarly achieve a near-optimal performance despite the challenging domains that may perhaps be paraphrased as an “anti-curriculum”: tasks are presented in an unordered sequence, follow in quick succession, and vary in orthogonal dimensions. For the POcman domain, partial observability further has the detrimental effect of making the different tasks more difficult to learn but also more difficult to distinguish from each other.4

⁴
Although anti-curricula do not appear too often in structured man-made environments, they tend to appear often in the animal kingdom or in robotic missions, where environmental changes require rapid adaptation with limited if any cues from the environment.

Moreover, due to the presentation of a variety of objects of interest, POcman is challenging since a recent benchmarking study within OpenAI Gym [7] and Multiworld [48] environments concluded that a variety of meta-/multi-task-RL approaches do not generalise well when the object of interest is varied [77]. Scaling up lifelong RL systems in such domains therefore presents a significant but exciting challenge, and the results provided by Lifetime Policy Reuse indicate a positive step in this direction. Adaptivity-wise, the study shows that bandit learning can provide a performance improvement comparable to a doubling of the number of policies, but only if task requirements and the policies in the library vary widely. While so far, studies incorporating adaptivity over policies have used static policy libraries which are only changed by adding newly converged policies and which are based on Markov Decision Processes, or have used a large amount of policies developed in an off-line stage of learning [14,16,52], this paper demonstrates the viability of adaptive policy selection with continual refinement based on the lifetime average performance to solve challenging lifelong learning sequences.

The theoretical task capacity provides a representational argument for the limited number of tasks that can be solved by a single policy. While a single policy can represent the optimal behaviour required for any one particular task, it can only represent the optimal behaviours for a limited number of tasks due to the conflicting state-action pairs that are required for different tasks. The empirical results show that the theoretical task capacity is one of the key limiting factors. The difficulty of epsilon-optimality over many tasks is illustrated for D(R)QN and PPO as a low-policy PPO could learn all tasks with low accuracy while a high-policy D(R)QN could learn all tasks with high accuracy. PPO’s objective function is clipped specifically to stimulate monotonic improvement over time [60]. This slow learning allows time to learn new patterns without erasing previously learned patterns and rather than representing a few tasks optimally, the policy represents a wide set of tasks sub-optimally. By contrast, the D(R)QN objective allows more aggressive weight updates resulting in either a near-optimal performance if a sufficient number of policies allows all tasks to be represented near-optimally, or in strong catastrophic interference and negative transfer otherwise. Further evidence of the importance of theoretical task capacity is that selective experience replay [29] or other modifications to experience replay do not improve single-policy DQN.

9. Conclusion

In lifelong reinforcement learning settings, a challenge is to avoid catastrophic forgetting and to stimulate selective transfer. This paper makes two novel contributions, namely 1) Lifetime Policy Reuse, a model-agnostic policy reuse algorithm that avoids generating many policies as tasks are being added across the lifetime; and 2) measures for task capacity, which help to pre-select a number of policies and analyse the performance of lifelong reinforcement learning systems in terms of the number of tasks a policy can learn or represent. Combining task capacity based pre-selection with Lifetime Policy Reuse demonstrates improved performance, transfer, forgetting, and memory consumption on 18-task POMDP sequences and 27- to 125-task MDP sequences with random temporal structure.

Footnotes

Acknowledgements

This research was funded by the Engineering and Physical Sciences Research Council and by Lloyd’s Register Foundation. The authors thank Nicholas Townsend for comments on an early draft of this paper and acknowledge the use of the IRIDIS High Performance Computing Facility and associated support services at the University of Southampton.

Implementation details

Additional analyses

References

Abel,

Jinna,

Guo,

Konidaris and

M.L.

Littman, Policy and value transfer in lifelong reinforcement learning, in: Proceedings of the International Conference on Machine Learning (ICML 2018), Stockholm, Sweden, 2018, pp. 1–10.

Andrychowicz,

Denil,

S.G.

Colmenarejo and

M.W.

Hoffman, Learning to learn by gradient descent by gradient descent, in: Proceedings of the Conference on Neural Information Processing Systems (NeurIPS 2016), 2016, pp. 1–17.

Auer,

Cesa-Bianchi and

Fischer, Finite-time analysis of the multiarmed bandit problem, Machine Learning 47(2–3) (2002), 235–256. doi:10.1023/A:1013689704352.

Baldi and

Vershynin, The capacity of feedforward neural networks, Neural Networks 116 (2019), 288–311. doi:10.1016/j.neunet.2019.04.009.

Bieger,

K.R.

Thorisson,

B.R.

Steunebrink,

Thorarensen and

J.S.

Sigurdardottir, Evaluation of general-purpose artificial intelligence: Why, what & how, in: Evaluating General-Purpose A.I. Workshop in the European Conference on Artificial Intelligence (ECAI 2016), The Hague, The Netherlands, 2016.

D.M.

Bossens,

N.C.

Townsend and

A.J.

Sobey, Learning to learn with active adaptive perception, Neural Networks 115 (2019), 30–49. doi:10.1016/j.neunet.2019.03.006.

Brockman,

Cheung,

Pettersson,

Schneider,

Schulman,

Tang and

Zaremba, OpenAI gym, 2016, 1–4. http://arxiv.org/abs/1606.01540.

Brunskill and

Li, PAC-inspired option discovery in lifelong reinforcement learning, in: Proceedings of the International Conference on Machine Learning (ICML 2014), Vol. 32, JMLR: W{&}CP, Beijing, China, 2014, pp. 316–324.

Burda,

Storkey,

Darrell and

A.A.

Efros, Large-scale study of curiosity-driven learning, in: Proceedings of the International Conference on Learning Representations (ICLR 2019), 2019, pp. 1–17.

10.

D.S.

Chaplot and

Lample, Arnold: An autonomous agent to play FPS games, in: Proceedings of the AAAI Conference on Artificial Intelligence (AAAI 2017), 2017, pp. 2–3.

11.

Chen and

Liu, Lifelong Machine Learning, Morgan & Claypool Publishers, 2016.

12.

W.C.

Cheung,

Simchi-Levi and

Zhu, Reinforcement learning for non-stationary Markov decision processes: The blessing of (more) optimism, in: Proceedings of the International Conference on Machine Learning (ICML 2020), 2020.

13.

Cohen,

Sharir,

Tamari and

Shashua, Analysis and design of convolutional networks, in: Why & when Deep Learning Works – Looking Inside Deep Learning, ICRI-CI paper bundle, Intel Collaborative Research Institute for Computational Intelligence (ICRI-CI), 2017.

14.

Cully,

Clune,

Tarapore and

J.B.

Mouret, Robots that can adapt like animals, Nature 521(7553) (2015), 503–507. doi:10.1038/nature14422.

15.

M.P.

Deisenroth,

Englert,

Peters and

Fox, Multi-task policy search, in: Proceedings of the IEEE International Conference on Robotics & Automation (ICRA 2014), Hong Kong, China, 2014, pp. 3876–3881. doi:10.1109/ICRA.2014.6907421.

16.

Fernández and

Veloso, Probabilistic policy reuse in a reinforcement learning agent, in: Proceedings of the International Conference on Autonomous Agents and Multiagent Systems (AAMAS 2006), 2006, pp. 720–727. doi:10.1145/1160633.1160762.

17.

Finn,

Abbeel and

Levine, Model-agnostic meta-learning for fast adaptation of deep networks, in: Proceedings of the International Conference on Machine Learning (ICML 2017), Sydney, Australia, 2017.

18.

Folli,

Leonetti and

Ruocco, On the maximum storage capacity of the Hopfield model, Frontiers in Computational Neuroscience 10 (2017), 1–9. doi:10.3389/fncom.2016.00144.

19.

R.M.

French, Semi-distributed representations and catastrophic forgetting in connectionist networks, Connection Science 4(3–4) (1992), 365–377. doi:10.1080/09540099208946624.

20.

Friedland and

Krell, A capacity scaling law for artificial neural networks, arXiv preprint, 2017, pp. 1–13. http://arxiv.org/abs/1708.06019.

21.

J.K.

Gupta,

Egorov and

Kochenderfer, Cooperative multi-agent control using deep reinforcement learning, in: Proceedings of the Conference on Autonomous Agents and Multiagent Systems (AAMAS 2017),

Sukthankar and

Rodriguez-Aguilar, eds, Vol. 5, 2017, pp. 66–83. doi:10.1007/978-3-319-71682-4_5.

22.

M.E.

Hasselmo, Avoiding catastrophic forgetting, Trends in Cognitive Sciences 21(6) (2017), 407–408. doi:10.1016/j.tics.2017.04.001.

23.

Hausknecht and

Stone, Deep recurrent Q-learning for partially observable MDPs, in: Proceedings of the AAAI Fall Symposium Series (FSS 2021), 2015, pp. 29–37.

24.

Heess,

TB,

Sriram,

Lemmon,

Merel,

Wayne,

Tassa,

Erez,

Wang,

S.M.A.

Eslami,

Riedmiller and

Silver, Emergence of locomotion behaviours in rich environments, arXiv preprint, 2017. http://arxiv.org/abs/1707.02286.

25.

Hernandez-Leal,

Rosman,

M.E.

Taylor,

L.E.

Sucar and

E.M.

De Cote, A Bayesian approach for learning and tracking switching, non-stationary opponents, in: Proceedings of the International Joint Conference on Autonomous Agents and Multiagent Systems (AAMAS 2016), 2016, pp. 1315–1316.

26.

Hochreiter and

J.H.

Schmidhuber, Long short-term memory, Neural Computation 9(8) (1997), 1–32. doi:10.1162/neco.1997.9.8.1735.

27.

Hochreiter,

A.S.

Younger and

P.R.

Conwell, Learning to learn using gradient descent, in: Proceedings of the International Conference on Artificial Neural Networks (ICANN 2001), Springer, 2001, pp. 87–94. doi:10.1007/3-540-44668-0.

28.

Hornik,

Stinchcombe and

White, Multilayer feedforward networks are universal approximators, Neural Networks 2(5) (1989), 359–366. doi:10.1016/0893-6080(89)90020-8.

29.

Isele and

Cosgun, Selective experience replay for lifelong learning, in: Proceedings of the AAAI Conference on Artificial Intelligence (AAAI 2018), 2018, pp. 3302–3309.

30.

Jung,

Ju,

Jung and

Kim, Less-forgetful learning for domain expansion in deep neural networks, in: Proceedings of the AAAI Conference on Artificial Intelligence (AAAI 18), 2017, pp. 3358–3365.

31.

Kapturowski,

Ostrovski,

Quan,

Munos and

Dabney, Recurrent experience replay in distributed reinforcement learning, in: Proceedings of the International Conference on Learning Representations (ICLR 2019), 2019, pp. 1–19.

32.

Kemker,

Mcclure,

Abitino,

T.L.

Hayes and

Kanan, Measuring catastrophic forgetting in neural networks, in: Proceedings of the AAAI Conference on Artificial Intelligence (AAAI 18), 2018, pp. 3390–3398.

33.

D.P.

Kingma and

J.L.

Ba, Adam: A method for stochastic optimisation, in: Proceedings of the International Conference on Learning Representations (ICLR 2015), 2015, pp. 1–15.

34.

Kirkpatrick,

Pascanu,

Rabinowitz,

Veness,

Desjardins and

A.A.

Rusu, Overcoming catastrophic forgetting in neural networks, Proceedings of the National Academy of Sciences of the United States of America (PNAS 2017) 114(13) (2017), 3521–3526. doi:10.1073/pnas.1611835114.

35.

Konidaris,

Scheidwasser and

A.G.

Barto, Transfer in reinforcement learning via shared features, Journal of Machine Learning Research 13(1) (2012), 1333–1371.

36.

Lample and

D.S.

Chaplot, Playing FPS games with deep reinforcement learning, in: Proceedings of the AAAI Conference on Artificial Intelligence (AAAI 2016), 2017, pp. 2140–2146.

37.

Lazaric, Transfer in reinforcement learning: A framework and a survey, in: Reinforcement Learning: State of the Art, Adaptation, Learning, and Optimization, Vol. 12, Springer, Berlin, Heidelberg, 2013, pp. 143–173. doi:10.1007/978-3-642-27645-3_5.

38.

Lecarpentier and

Rachelson, Non-stationary Markov decision processes: A worst-case approach using model-based reinforcement learning, in: Proceedings of the Conference on Neural Information Processing Systems (NeurIPS 2019), 2019.

39.

Levy,

Platt,

Konidaris and

Saenko, Learning multi-level hierarchies with hindsight, in: Proceedings of the International Conference on Learning Representations (ICLR 2019), 2019, pp. 1–16.

40.

Li,

Gu,

Zhu and

Zhang, Context-aware policy reuse, in: Proceedings of the International Conference on Autonomous Agents and Multi-Agent Systems (AAMAS 2018), 2018.

41.

Li,

Wang,

Tang and

Zhang, Hierarchical reinforcement learning with advantage-based auxiliary rewards, arXiv, 2019, Vancouver, Canada.

42.

Li and

Zhang, An optimal online method of selecting source policies for reinforcement learning, in: Proceedings of the AAAI Conference on Artificial Intelligence (AAAI 2018), 2018, pp. 3562–3570.

43.

Li and

Hoiem, Learning without forgetting, IEEE Transactions on Pattern Analysis and Machine Intelligence 40(12) (2018), 2935–2947. doi:10.1109/TPAMI.2017.2773081.

44.

Lomonaco,

Desai,

Culurciello and

Maltoni, Continual reinforcement learning in 3D non-stationary environments, in: Continual Learning Workshop at the IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR 2020), 2020, pp. 999–1008. doi:10.1109/CVPRW50498.2020.00132.

45.

A.K.

McCallum, Reinforcement learning with selective perception and hidden state, PhD thesis, University of Rochester, 1995.

46.

Mnih,

Kavukcuoglu,

Silver,

A.A.

Rusu,

Veness,

M.G.

Bellemare,

Graves,

Riedmiller,

A.K.

Fidjeland,

Ostrovski,

Petersen,

Beattie,

Sadik,

Antonoglou,

King,

Kumaran,

Wierstra,

Legg and

Hassabis, Human-level control through deep reinforcement learning, Nature 518(7540) (2015), 529–533. doi:10.1038/nature14236.

47.

Naik,

Shariff,

Yasui,

Yao and

R.S.

Sutton, Discounted reinforcement learning is not an optimization problem, in: Optimization Foundations for Reinforcement Learning Workshop at the Conference on Neural Information Processing Systems (NeurIPS 2019), Vancouver, Canada, 2019, pp. 1–7.

48.

Nair,

Pong,

Dalal,

Bahl,

Lin and

Levine, Visual reinforcement learning with imagined goals, in: Advances in Neural Information Processing Systems (NeurIPS 2018), 2018, pp. 9191–9200.

49.

Nichol,

Pfau,

Hesse,

Klimov and

Schulman, Gotta learn fast: A new benchmark for generalization in RL, arXiv preprint, 2018, pp. 1–21. http://arxiv.org/abs/1804.03720.

50.

S.J.

Pan and

Yang, A survey on transfer learning, IEEE Transactions on Knowledge and Data Engineering 22(10) (2010), 1345–1359. doi:10.1109/TKDE.2009.191.

51.

Riemer,

Cases,

Ajemian,

Liu,

Rish,

Tu and

Tesauro, Learning to learn without forgetting by maximizing transfer and minimizing interference, in: Proceedings of the International Conference on Learning Representations (ICLR 2019), 2019.

52.

Rosman,

Hawasly and

Ramamoorthy, Bayesian policy reuse, Machine Learning 104 (2016), 99–127. doi:10.1007/s10994-016-5547-y.

53.

Rostami,

Isele and

Eaton, Using task descriptions in lifelong machine learning for improved performance and zero-shot transfer, Journal of Artificial Intelligence Research 67 (2020), 673–703. doi:10.1613/JAIR.1.11304.

54.

D.E.

Rumelhart,

G.E.

Hinton and

R.J.

Williams, Learning representations by back-propagating errors, Nature 323(5) (1986), 533–536. doi:10.1038/323533a0.

55.

A.A.

Rusu,

N.C.

Rabinowitz,

Desjardins,

Soyer,

Kirkpatrick,

Kavukcuoglu,

Pascanu and

Hadsell, Progressive neural networks, arXiv preprint, 2016, pp. 1–5.

56.

A.M.

Schäfer and

H.G.

Zimmermann, Recurrent neural networks are universal approximators, in: Proceedings of the International Conference on Artificial Neural Networks (ICANN 2007), 17,

Kollias,

Stafylopatis,

Duch and

Oja, eds, Springer, Athens, Greece, 2007, pp. 253–263. doi:10.1142/s0129065707001111.

57.

Schaul,

Horgan,

Gregor and

Silver, Universal value function approximators, in: Proceedings of the International Conference on Machine Learning (ICML 2015), Lille, France, 2015, pp. 1312–1320.

58.

J.H.

Schmidhuber, A general method for incremental self-improvement and multi-agent learning, in: Evolutionary Computation: Theory and Applications,

Yao, ed., Vol. 1, World Scientific, 1999, pp. 81–123, Chapter 3. doi:10.1142/9789812817471_0003.

59.

Schulman,

Moritz,

Levine,

M.I.

Jordan and

Abbeel, High-dimensional continuous control using generalised advantage estimation, in: Proceedings of the International Conference on Learning Representations (ICLR 2016), 2016.

60.

Schulman,

Wolski,

Dhariwal,

Radford and

Klimov, Proximal policy optimization algorithms, arXiv preprint, 2017, pp. 1–12. http://arxiv.org/abs/1707.06347.

61.

Schulze and

Schulze, ViZDoom: DRQN with prioritized experience replay, double-q learning, & snapshot ensembling, in: Proceedings of the SAI Intelligent Systems Conference (IntelliSys 2018), 2018, pp. 1–17.

62.

D.L.

Silver,

Yang and

Li, Lifelong machine learning systems: Beyond learning algorithms, in: AAAI Spring Symposium Series (SSS 2013), 2013, pp. 49–55.

63.

E.D.

Sontag, VC dimension of neural networks, NATO ASI Series F Computer and Systems Sciences 168 (1998), 69–96. https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.63.9443.

64.

R.S.

Sutton and

A.G.

Barto, Reinforcement Learning: An Introduction, 2nd edn, MIT Press, 2017. doi:10.1016/s1364-6613(99)01331-5.

65.

M.E.

Taylor and

Stone, Transfer learning for reinforcement learning domains: A survey, Journal of Machine Learning Research 10 (2009), 1633–1685.

66.

J.K.

Terry,

Grammel,

Son and

Black, Parameter sharing for heterogeneous agents in multi-agent reinforcement learning, 2020, http://arxiv.org/abs/2005.13625.

67.

Tessler,

Givony,

Zahavy,

D.J.

Mankowitz and

Mannor, A deep hierarchical approach to lifelong learning in minecraft, in: Proceedings of the AAAI Conference on Artificial Intelligence (AAAI 2016), 2016, pp. 55–1561.

68.

Thrun and

Schwartz, Finding structure in reinforcement learning, in: Advances in Neural Information Processing Systems (NeurIPS 1995), 1995, pp. 385–392.

69.

Thrun and

J.O.

Sullivan, Clustering learning tasks and the selective cross-task transfer of knowledge, Technical Report, School of Computer Science, Carnegie Mellon University, Pittsburgh, USA, 1995.

70.

University of Southampton, The Iridis Compute Cluster, 2017. https://www.southampton.ac.uk/isolutions/staff/iridis.page.

71.

V.N.

Vapnik and

A.Y.

Chervonenkis, On the uniform convergence of relative frequencies of events to their probabilities, Theory of probability and its applications 16(2) (1971), 264–280. doi:10.1137/1116025.

72.

Veness,

K.S.

Ng,

Hutter,

Uther and

Silver, A Monte-Carlo AIXI approximation, Journal of Artificial Intelligence Research 40 (2011), 95–142. doi:10.1613/jair.3125.

73.

Wang,

Liu,

Chen,

Z.-M.

Ma and

T.-Y.

Liu, Target transfer Q-learning and its convergence analysis, Neurocomputing 392 (2020), 11–22. doi:10.1016/j.neucom.2020.02.117.

74.

C.J.C.H.

Watkins and

Dayan, Q-learning, Machine Learning 8(3–4) (1992), 279–292. doi:10.1007/BF00992698.

75.

Wilson,

Fern,

Ray and

Tadepalli, Multi-task reinforcement learning: A hierarchical Bayesian approach, in: Proceedings of the International Conference on Machine Learning (ICML 2007), 2007, pp. 1015–1022. doi:10.1145/1273496.1273624.

76.

Xu,

Liu,

Zhao and

Peng, Learning to explore via meta-policy gradient, in: Proceedings of the International Conference on Machine Learning (ICML 2018), Vol. 12, Stockholm, Sweden, 2018, pp. 8686–8706.

77.

Yu,

Quillen,

He,

Julian,

Hausman,

Finn and

Levine, Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning, in: Proceedings of the Conference on Robot Learning (CoRL 2019), 2019, pp. 1–18.

78.

M.D.

Zeiler, ADADELTA: An adaptive learning rate method, arXiv preprint, 2012, pp. 1–6. http://arxiv.org/abs/1212.5701. ISBN 1212.5701.

79.

Zheng,

Meng,

Hao,

Zhang,

Yang and

Fan, A deep Bayesian policy reuse approach against non-stationary agents, in: Advances in Neural Information Processing Systems (NeurIPS 2018), 2018, pp. 954–964.

Lifetime policy reuse and the importance of task capacity

Abstract

Keywords

1. The importance of efficient learning over multiple tasks

2. Reinforcement learning setup

3. Lifelong reinforcement learning: A review

3.1. Single-policy methods

3.2. Policy reuse

3.3. Alternative multi-policy methods

3.4. Meta-learning

4. Lifetime policy reuse

4.2. Policy selector

4.3. Model-agnostic algorithm

5.1. Solving multiple tasks accurately

6. Experiment setup

6.1. Base-learners

6.3. Lifelong learning domains

7.1. 27-task Cartpole MDP domain

2 All significance values reported in this paper are based on pair-wise F-tests between the conditions, and p < 0.01 is considered as statistically significant.

4 Although anti-curricula do not appear too often in structured man-made environments, they tend to appear often in the animal kingdom or in robotic missions, where environmental changes require rapid adaptation with limited if any cues from the environment.

Footnotes

Acknowledgements

Implementation details

Additional analyses

References

²
All significance values reported in this paper are based on pair-wise F-tests between the conditions, and $p < 0.01$ is considered as statistically significant.

⁴
Although anti-curricula do not appear too often in structured man-made environments, they tend to appear often in the animal kingdom or in robotic missions, where environmental changes require rapid adaptation with limited if any cues from the environment.