Transfer in Deep Reinforcement Learning Using Successor Features and Generalised Policy Improvement

TL;DR

This paper extends the successor features and generalised policy improvement framework for transfer in deep reinforcement learning, allowing for more flexible reward representations and demonstrating rapid transfer in complex 3D environments.

Contribution

It relaxes the linear reward assumption and uses reward functions as features, enabling more stable deep RL transfer without predefining features.

Findings

Rapid transfer to unseen tasks in complex environments

Reward functions can serve as features without loss of expressiveness

Enhanced stability in deep reinforcement learning transfer

Abstract

The ability to transfer skills across tasks has the potential to scale up reinforcement learning (RL) agents to environments currently out of reach. Recently, a framework based on two ideas, successor features (SFs) and generalised policy improvement (GPI), has been introduced as a principled way of transferring skills. In this paper we extend the SFs & GPI framework in two ways. One of the basic assumptions underlying the original formulation of SFs & GPI is that rewards for all tasks of interest can be computed as linear combinations of a fixed set of features. We relax this constraint and show that the theoretical guarantees supporting the framework can be extended to any set of tasks that only differ in the reward function. Our second contribution is to show that one can use the reward functions themselves as features for future tasks, without any loss of expressiveness, thus removing the need to specify a set of features beforehand. This makes it possible to combine SFs & GPI with deep learning in a more stable way. We empirically verify this claim on a complex 3D environment where observations are images from a first-person perspective. We show that the transfer promoted by SFs & GPI leads to very good policies on unseen tasks almost instantaneously. We also describe how to learn policies specialised to the new tasks in a way that allows them to be added to the agent's set of skills, and thus be reused in the future.

Figures

Equations

$$Q^{\pi }(s,a)\equiv {\mathrm{E}}^{\pi }\left[G_t|S_t=s,A_t=a\right],$$

$$r(s,a,s^{\prime })=\varphi (s,a,s^{\prime }{)}^{\top }\mathrm{w},$$

$${\mathcal{M}}^{\varphi }\equiv \{M(\mathcal{S},\mathcal{A},p,r,\gamma )|r(s,a,s^{\prime })=\varphi (s,a,s^{\prime }{)}^{\top }\mathrm{w}\},$$

$$Q_i^{\pi }(s,a)$$

$$\equiv {\psi }^{\pi }(s,a{)}^{\top }{\mathrm{w}}_i,$$

$${\psi }^{\pi }(s,a)$$

$$\mathcal{M}(\mathcal{S},\mathcal{A},p,\gamma )\equiv \{M(\mathcal{S},\mathcal{A},p,\cdot ,\gamma )\}.$$

$$\pi (s)\in {\mathrm{argmax}}_a{\max }_j{\tilde{Q}}_i^{{\pi }_j}(s,a).$$

$$\Vert Q^{\ast }-Q^{\pi }{\Vert }_{\infty }\le \frac{2}{1-\gamma }\left(\Vert r-r_i{\Vert }_{\infty }+{\min }_j\Vert r_i-r_j{\Vert }_{\infty }+ϵ\right),$$

$$\tilde{\varphi }(s,a,s^{\prime }{)}^{\top }{\tilde{\mathrm{w}}}_i\approx r_i(s,a,s^{\prime }),\text{ for }i=1,2,...,D,$$

$$\tilde{\varphi }(s,a,s^{\prime })=\tilde{\mathrm{r}}(s,a,s^{\prime })\approx \mathrm{r}(s,a,s^{\prime }).$$

$$|Q^{{\pi }_i}(s,a)-{\tilde{Q}}^{{\pi }_i}(s,a)|\le ϵ\text{ for all }s\in S,a\in A,\text{ and }i\in \{1,2,...,n\}.$$

$$\pi (s)\in {\mathrm{argmax}}_a\underset{i}{\max }{\tilde{Q}}^{{\pi }_i}(s,a).$$

$$Q^{\pi }(s,a)\ge \underset{i}{\max }{Q}^{{\pi }_i}(s,a)-\frac{2}{1-\gamma }ϵ$$

$$|Q_i^{\pi }(s,a)-Q_j^{\pi }(s,a)|\le \frac{{\delta }_{ij}}{1-\gamma }.$$

$$|Q_i^{\pi }(s,a)-Q_j^{\pi }(s,a)|$$

$$=\left|r_i(s,a)-r_j(s,a)+\gamma \sum _{s^{\prime }}p(s^{\prime }|s,a)\left(Q_i^{\pi }(s^{\prime },\pi (s^{\prime }))-Q_j^{\pi }(s^{\prime },\pi (s^{\prime }))\right)\right|$$

$$\le \left|r_i(s,a)-r_j(s,a)\right|+\gamma \sum _{s^{\prime }}p(s^{\prime }|s,a)\left|Q_i^{\pi }(s^{\prime },\pi (s^{\prime }))-Q_j^{\pi }(s^{\prime },\pi (s^{\prime }))\right|$$

$$\le {\delta }_{ij}+\gamma {\Delta }_{ij}.$$

$${\Delta }_{ij}\le \frac{1}{1-\gamma }{\delta }_{ij}.$$

$$|Q_i^{{\pi }_i^{\ast }}(s,a)-Q_j^{{\pi }_j^{\ast }}(s,a)|\le \frac{{\delta }_{ij}}{1-\gamma }.$$

$$|Q_i^i(s,a)-Q_j^j(s,a)|$$

$$=\left|r_i(s,a)-r_j(s,a)+\gamma \sum _{s^{\prime }}p(s^{\prime }|s,a)\left(\underset{b}{\max }{Q}_i^i(s^{\prime },b)-\underset{b}{\max }{Q}_j^j(s^{\prime },b)\right)\right|$$

$$\le \left|r_i(s,a)-r_j(s,a)\right|+\gamma \sum _{s^{\prime }}p(s^{\prime }|s,a)\left|\underset{b}{\max }{Q}_i^i(s^{\prime },b)-\underset{b}{\max }{Q}_j^j(s^{\prime },b)\right|$$

$$\le \left|r_i(s,a)-r_j(s,a)\right|+\gamma \sum _{s^{\prime }}p(s^{\prime }|s,a)\underset{b}{\max }\left|Q_i^i(s^{\prime },b)-Q_j^j(s^{\prime },b)\right|$$

$$\le {\delta }_{ij}+\gamma {\Delta }_{ij}.$$

$${\Delta }_{ij}\le \frac{1}{1-\gamma }{\delta }_{ij}.$$

$$\pi (s)\in {\mathrm{argmax}}_a{\max }_j{\tilde{Q}}_i^{{\pi }_j}(s,a).$$

$$\Vert Q^{\ast }-Q^{\pi }{\Vert }_{\infty }\le \frac{2}{1-\gamma }\left(\Vert r-r_i{\Vert }_{\infty }+{\min }_j\Vert r_i-r_j{\Vert }_{\infty }+ϵ\right),$$

$$\begin{array}[]{llr}Q^{*}(s,a)-Q^{\pi}(s,a)&=Q^{\pi^{*}}(s,a)-Q^{\pi}(s,a)\\ &=Q^{\pi^{*}}(s,a)-Q^{\pi^{*}_{i}}_{i}+Q^{\pi^{*}_{i}}_{i}-Q^{\pi}(s,a)\\ &=Q^{\pi^{*}}(s,a)-Q^{\pi^{*}_{i}}_{i}+Q^{\pi^{*}_{i}}_{i}-Q^{\pi}_{i}+Q^{\pi}_{i}-Q^{\pi}(s,a)\\ &\leq|Q^{\pi^{*}}(s,a)-Q^{\pi^{*}_{i}}_{i}|+Q^{\pi^{*}_{i}}_{i}-Q^{\pi}_{i}+|Q^{\pi}_{i}-Q^{\pi}(s,a)|\\ \end{array}$$

$$|Q^{{\pi }^{\ast }}(s,a)-Q_i^{{\pi }_i^{\ast }}|\le \frac{{\max }_{s,a}\left|r(s,a)-r_i(s,a)\right|}{1-\gamma }.$$

$$\begin{array}[]{llr}Q_{i}^{\pi_{i}^{*}}(s,a)-Q^{\pi}_{i}(s,a)&\leq Q_{i}^{\pi_{i}^{*}}(s,a)-Q^{\pi_{j}^{*}}_{i}(s,a)+\dfrac{2}{1-\gamma}\epsilon&\text{(Theorem~{}\ref{teo:gpi})}\\ &=Q_{i}^{\pi_{i}^{*}}(s,a)-Q^{\pi_{j}^{*}}_{j}(s,a)+Q^{\pi_{j}^{*}}_{j}(s,a)-Q^{\pi_{j}^{*}}_{i}(s,a)+\dfrac{2}{1-\gamma}\epsilon\\ &\leq|Q_{i}^{\pi_{i}^{*}}(s,a)-Q^{\pi_{j}^{*}}_{j}(s,a)|+|Q^{\pi_{j}^{*}}_{j}(s,a)-Q^{\pi_{j}^{*}}_{i}(s,a)|+\dfrac{2}{1-\gamma}\epsilon\\ &\leq\dfrac{2}{1-\gamma}\max_{s,a}\left|r_{i}(s,a)-r_{j}(s,a)\right|+\dfrac{2}{1-\gamma}\epsilon&\text{(Lemmas~{}\ref{teo:bound_pair2} and~{}\ref{teo:bound_pair3})}.\\ \end{array}$$

$$|Q_i^{\pi }-Q^{\pi }(s,a)|\le \frac{{\max }_{s,a}\left|r(s,a)-r_i(s,a)\right|}{1-\gamma }.$$

Full text

Machine Learning, ICML

1 Introduction

In recent years reinforcement learning (RL) has undergone a major change in terms of the scale of its applications: from relatively small and well-controlled benchmarks to problems designed to challenge humans—who are now consistently outperformed by artificial agents in domains considered out of reach only a few years ago (Mnih et al., 2015; Bowling et al., 2015; Silver et al., 2016, 2017).

At the core of this shift has been deep learning, a machine learning paradigm that recently attracted a lot of attention due to impressive accomplishments across many areas (Goodfellow et al., 2016). Despite the successes achieved by the combination of deep learning and RL, dubbed “deep RL”, the agents’s basic mechanics have remained essentially the same, with each problem tackled as an isolated monolithic challenge. An alternative would be for our agents to decompose a problem into smaller sub-problems, or “tasks”, whose solutions can be reused multiple times, in different scenarios. This ability of explicitly transferring skills to quickly adapt to new tasks could lead to another leap in the scale of RL applications.

Recently, Barreto et al. (2017) proposed a framework for transfer based on two ideas: generalised policy improvement (GPI), a generalisation of the classic dynamic-programming operation, and successor features (SFs), a representation scheme that makes it possible to quickly evaluate a policy across many tasks. The SF & GPI approach is appealing because it allows transfer to take place between any two tasks, regardless of their temporal order, and it integrates almost seamlessly into the RL framework.

In this paper we extend Barreto et al.’s (2017) framework in two ways. First, we argue that its applicability is broader than initially shown. SF & GPI was designed for the scenario where each task corresponds to a different reward function; one of the basic assumptions in the original formulation was that the rewards of all tasks can be computed as a linear combination of a fixed set of features. We show that such an assumption is not strictly necessary, and in fact it is possible to have guarantees on the performance of the transferred policy even on tasks that are not in the span of the features.

The realisation above adds some flexibility to the problem of computing features that are useful for transfer. Our second contribution is to show a simple way of addressing this problem that can be easily combined with deep learning. Specifically, by looking at the associated approximation from a slightly different angle, we show that one can replace the features with actual rewards. This makes it possible to apply SF & GPI online at scale. In order to verify this claim, we revisit one of Barreto et al.’s (2017) experiments in a much more challenging format, replacing a fully observable $2$-dimensional environment with a $3$-dimensional domain where observations are images from a first-person perspective. We show that the transfer promoted by SF & GPI leads to good policies on unseen tasks almost instantaneously. Furthermore, we show how to learn policies that are specialised to the new tasks in a way that allows them to be added to the agent’s ever-growing set of skills, a crucial ability for continual learning (Thrun, 1996).

2 Background

In this section we present the background material that will serve as a foundation for the rest of the paper.

2.1 Reinforcement learning

In RL an agent interacts with an environment and selects actions in order to maximise the expected amount of reward received (Sutton & Barto, 1998). We model this scenario using the formalism of Markov decision processes (MDPs, Puterman, 1994). An MDP is a tuple $M\equiv(\mathcal{S},\mathcal{A},p,R,\gamma)$ whose components are defined as follows. The sets $\mathcal{S}$ and $\mathcal{A}$ are the state and action spaces, respectively. The function $p$ defines the dynamics of the MDP: specifically, $p(\cdot|s,a)$ gives the next-state distribution upon taking action $a$ in state $s$. The random variable $R(s,a,s^{\prime})$ determines the reward received in the transition $s\xrightarrow{a}s^{\prime}$; it is often convenient to consider the expected value of this variable, $r(s,a,s^{\prime})$. Finally, the discount factor $\gamma\in[0,1)$ gives smaller weights to future rewards. Given an MDP, the goal is to maximise the expected return $G_{t}=\sum_{i=0}^{\infty}\gamma^{i}R_{t+i},$ where $R_{t}=R(S_{t},A_{t},S_{t+1})$. In order to do so the agent computes a policy $\pi:\mathcal{S}\mapsto\mathcal{A}$.

A principled way to address the RL problem is to use methods derived from dynamic programming (DP) (Puterman, 1994). RL methods based on DP usually compute the action-value function of a policy $\pi$, defined as:

[TABLE]

where $\mathrm{E}^{\pi}[\cdot]$ denotes expectation over the sequences of transitions induced by $\pi$. The computation of $Q^{\pi}(s,a)$ is called policy evaluation. Once a policy $\pi$ has been evaluated, we can compute a greedy policy $\pi^{\prime}(s)\in\mathrm{argmax}_{a}Q^{\pi}(s,a)$ that is guaranteed to perform at least as well as $\pi$, that is: $Q^{\pi^{\prime}}(s,a)\geq Q^{\pi}(s,a)$ for any $(s,a)\in\mathcal{S}\times\mathcal{A}$. The computation of $\pi^{\prime}$ is referred to as policy improvement. The alternation between policy evaluation and policy improvement is at the core of many DP-based RL algorithms, which usually carry out these steps only approximately.

As a convention, we will add a tilde to a symbol to indicate that the associated quantity is an approximation; we will then refer to the respective tunable parameters as $\boldsymbol{\mathrm{\theta}}$. For example, the agent computes an approximation $\tilde{Q}^{\pi}\approx Q^{\pi}$ by tuning $\boldsymbol{\mathrm{\theta}}_{Q}$. In deep RL some of the approximations computed by the agent, like $\tilde{Q}^{\pi}$, are represented by complex nonlinear approximators composed of many levels of nested tunable functions; among these, the most popular models are by far deep neural networks (Goodfellow et al., 2016).

In this paper we are interested in the problem of transfer in RL (Taylor & Stone, 2009; Lazaric, 2012). Specifically, we ask the question: given a set of MDPs that only differ in their reward function, how can we leverage knowledge gained in some MDPs to speed up the solution of others?

2.2 SF & GPI

Barreto et al. (2017) propose a framework to solve a restricted version of the problem above. Specifically, they restrict the scenario of interest to MDPs whose expected one-step reward can be written as

[TABLE]

where $\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})\in\mathbb{R}^{d}$ are features of $(s,a,s^{\prime})$ and $\boldsymbol{\mathrm{w}}\in\mathbb{R}^{d}$ are weights. In order to build some intuition, it helps to think of $\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})$ as salient events that may be desirable or undesirable to the agent. Based on (2) one can define an environment $\mathcal{M}^{\phi}(\mathcal{S},\mathcal{A},p,\gamma)$ as

[TABLE]

that is, $\mathcal{M}^{\phi}$ is the set of MDPs induced by $\boldsymbol{\mathrm{\phi}}$ through all possible instantiations of $\boldsymbol{\mathrm{w}}$. We call each $M\in\mathcal{M}^{\phi}$ a task. Given a task $M_{i}\in\mathcal{M}^{\phi}$ defined by $\boldsymbol{\mathrm{w}}_{i}\in\mathbb{R}^{d}$, we will use $Q^{\pi}_{i}$ to refer to the value function of $\pi$ on $M_{i}$.

Barreto et al. (2017) propose SF & GPI as a way to promote transfer between tasks in $\mathcal{M}^{\phi}$. As the name suggests, GPI is a generalisation of the policy improvement step described in Section 2.1. The difference is that in GPI the improved policy is computed based on a set of value functions rather than on a single one. Let $Q^{\pi_{1}},Q^{\pi_{2}},...Q^{\pi_{n}}$ be the action-value functions of $n$ policies defined on a given MDP, and let $Q^{\max}=\max_{i}Q^{\pi_{i}}$. If we define $\pi(s)\leftarrow\mathrm{argmax}_{a}Q^{\max}(s,a)$ for all $s\in\mathcal{S}$, then $Q^{\pi}(s,a)\geq Q^{\max}(s,a)$ for all $(s,a)\in\mathcal{S}\times\mathcal{A}$. The result also extends to the scenario where we replace $Q^{\pi_{i}}$ with approximations $\tilde{Q}^{\pi_{i}}$, in which case the lower bound on $Q^{\pi}(s,a)$ gets looser with the approximation error, as in approximate DP (Bertsekas & Tsitsiklis, 1996).

In the context of transfer, GPI makes it possible to leverage knowledge accumulated over time, across multiple tasks, to learn a new task faster. Suppose that the agent has access to $n$ policies $\pi_{1},\pi_{2},...,\pi_{n}$. These can be arbitrary policies, but for the sake of the argument let us assume they are solutions for tasks $M_{1}$, $M_{2}$, …, $M_{n}$. Suppose also that when exposed to a new task $M_{n+1}\in\mathcal{M}^{\phi}$ the agent computes $Q^{{}_{\pi_{i}}}_{n+1}$—the value functions of the policies $\pi_{i}$ under the reward function induced by $\boldsymbol{\mathrm{w}}_{n+1}$. In this case, applying GPI to the set $\{Q^{\pi_{1}}_{n+1},Q^{\pi_{2}}_{n+1},...,Q^{\pi_{n}}_{n+1}\}$ will result in a policy that performs at least as well as any of the policies $\pi_{i}$.

Clearly, the approach above is appealing only if we have a way to quickly compute the value functions of the policies $\pi_{i}$ on the task $M_{n+1}$. This is where SFs come in handy. SFs make it possible to compute the value of a policy $\pi$ on any task $M_{i}\in\mathcal{M}^{\phi}$ by simply plugging in the representation the vector $\boldsymbol{\mathrm{w}}_{i}$ defining the task. Specifically, if we substitute (2) in (1) we have

[TABLE]

where $\boldsymbol{\mathrm{\phi}}_{t}=\boldsymbol{\mathrm{\phi}}(s_{t},a_{t},s_{t+1})$ and $\boldsymbol{\mathrm{\psi}}^{\pi}(s,a)$ are the SFs of $(s,a)$ under policy $\pi$. As one can see, SFs decouple the dynamics of the MDP $M_{i}$ from its rewards (Dayan, 1993). One benefit of doing so is that if we replace $\boldsymbol{\mathrm{w}}_{i}$ with $\boldsymbol{\mathrm{w}}_{j}$ in  (2.2) we immediately obtain the evaluation of $\pi$ on task $M_{j}$. It is also easy to show that

[TABLE]

that is, SFs satisfy a Bellman equation in which $\phi_{i}$ play the role of rewards. Therefore, SFs can be learned using any conventional RL method (Szepesvári, 2010).

The combination of SFs and GPI provides a general framework for transfer in environments of the form (3). Suppose that we have learned the functions $Q^{{}_{\pi_{i}}}_{i}$ using the representation scheme (2.2). When exposed to the task defined by $r_{n+1}(s,a,s^{\prime})=\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})^{\top}\boldsymbol{\mathrm{w}}_{n+1}$, as long as we have $\boldsymbol{\mathrm{w}}_{n+1}$ we can immediately compute $Q^{{}_{\pi_{i}}}_{n+1}(s,a)=\boldsymbol{\mathrm{\psi}}^{{}_{\pi_{i}}}(s,a)^{\top}\boldsymbol{\mathrm{w}}_{n+1}$. This reduces the computation of all ${Q}^{{}_{\pi_{i}}}_{n+1}$ to the problem of determining $\boldsymbol{\mathrm{w}}_{n+1}$, which can be posed as a supervised learning problem whose objective is to minimise some loss derived from (2). Once ${Q}^{{}_{\pi_{i}}}_{n+1}$ have been computed, we can apply GPI to derive a policy $\pi$ that is no worse, and possibly better, than $\pi_{1},...,\pi_{n}$ on task $M_{n+1}$.

3 Extending the notion of environment

Barreto et al. (2017) focus on environments of the form (3). In this paper we propose a more general notion of environment:

[TABLE]

$\mathcal{M}$ contains all MDPs that share the same $\mathcal{S}$, $\mathcal{A}$, $p$, and $\gamma$, regardless of whether their rewards can be computed as a linear combination of the features $\boldsymbol{\mathrm{\phi}}$. Clearly, $\mathcal{M}\supset\mathcal{M}^{\phi}$.

We want to devise a transfer framework for environment $\mathcal{M}$. Ideally this framework should have two properties. First, it should be principled, in the sense that we should be able to provide theoretical guarantees regarding the performance of the transferred policies. Second, it should give rise to simple methods that are applicable in practice, preferably in combination with deep learning. Surprisingly, we can have both of these properties by simply looking at SF & GPI from a slightly different point of view, as we show next.

3.1 Guarantees on the extended environment

Barreto et al. (2017) provide theoretical guarantees on the performance of SF & GPI applied to any task $M\in\mathcal{M}^{\phi}$. In this section we show that it is in fact possible to derive guarantees for any task in $\mathcal{M}$. Our main result is below:

Proposition 1**.**

Let $M\in\mathcal{M}$ and let $Q^{\pi_{j}^{*}}_{i}$ be the action-value function of an optimal policy of $M_{j}\in\mathcal{M}$ when executed in $M_{i}\in\mathcal{M}$. Given approximations $\{\tilde{Q}^{\pi_{1}}_{i},\tilde{Q}^{\pi_{2}}_{i},...,\tilde{Q}^{\pi_{n}}_{i}\}$ such that $\left|Q^{\pi_{j}^{*}}_{i}(s,a)-\tilde{Q}^{\pi_{j}}_{i}(s,a)\right|\leq\epsilon$ for all $s\in\mathcal{S}$, $a\in\mathcal{A}$, and $j\in\{1,2,...,n\}$, let

[TABLE]

Then,

[TABLE]

where $Q^{*}$ is the optimal value function of $M$, $Q^{\pi}$ is the value function of $\pi$ in $M$, and $\|f-g\|_{\infty}=\max_{s,a}|f(s,a)-g(s,a)|$.

The proof of Proposition 1 is in the supplementary material. Our result provides guarantees on the performance of the GPI policy (7) applied to an MDP $M$ with arbitrary reward function $r(s,a)$. Note that, although the proposition does not restrict any of the tasks to be in $\mathcal{M}^{\phi}$, in order to compute the GPI policy (7) we still need an efficient way of evaluating the policies $\pi_{j}$ on task $M_{i}$. As explained in Section 2, one way to accomplish this is to assume that $M_{i}$ and all $M_{j}$ appearing in the statement of the proposition belong to $\mathcal{M}^{\phi}$; this allows the use of SFs to quickly compute $\tilde{Q}^{\pi_{j}}_{i}(s,a)$.

Let us thus take a closer look at Proposition 1 under the assumption that all MDPs belong to $\mathcal{M}^{\phi}$, except perhaps for $M$. The proposition is based on a reference MDP $M_{i}\in\mathcal{M}^{\phi}$. If $M_{i}=M_{j}$ for some $j$, the second term of (8) disappears, and we end up with a lower bound on the performance of a policy computed for $M_{i}$ when executed in $M$. More generally, one should think of $M_{i}$ as the MDP in $\mathcal{M}^{\phi}$ that is “closest” to $M$ in some sense (so it may be that $M_{i}\neq M_{j}$ for all $j$). Specifically, if $r_{i}(s,a,s^{\prime})=\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})^{\top}\boldsymbol{\mathrm{w}}_{i}$, we can think of $\boldsymbol{\mathrm{w}}_{i}$ as the vector that provides the best approximation $\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})^{\top}\boldsymbol{\mathrm{w}}_{i}\approx r(s,a,s^{\prime})$ under some well-defined criterion. The first term of (8) can thus be seen as the “distance” between $M$ and $\mathcal{M}^{\phi}$, which suggests that the performance of SF & GPI should degrade gracefully as we move away from the original environment $\mathcal{M}^{\phi}$. In the particular case where $M\in\mathcal{M}^{\phi}$ the first term of (8) vanishes, and we recover Barreto et al.’s (2017) Theorem 2.

3.2 Uncovering the structure of the environment

We want to solve a subset of the tasks in $\mathcal{M}$ and use GPI to promote transfer between these tasks. In order to do so efficiently, we need a function $\boldsymbol{\mathrm{\phi}}$ that covers the tasks of interest as much as possible. If we were to rely on Barreto et al.’s (2017) original results, we would have guarantees on the performance of the GPI policy only if $\boldsymbol{\mathrm{\phi}}$ spanned all the tasks of interest. Proposition 1 allows us to remove this requirement, since now we have theoretical guarantees for any choice of $\boldsymbol{\mathrm{\phi}}$. In practice, though, we want features $\boldsymbol{\mathrm{\phi}}$ such that the first term of (8) is small for all tasks of interest.

There might be contexts in which we have direct access to features $\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})$ that satisfy (2), either exactly or approximately. Here though we are interested in the more general scenario where this structure is not available, nor given to the agent in any form. In this case the use of SFs requires a way of unveiling such a structure.

Barreto et al. (2017) assume the existence of a $\boldsymbol{\mathrm{\phi}}\in\mathbb{R}^{d}$ that satisfy (2) exactly and formulate the problem of computing an approximate $\tilde{\boldsymbol{\mathrm{\phi}}}$ as a multi-task learning problem. The problem is decomposed into $D$ regressions, each one associated with a task. For reasons that will become clear shortly we will call these tasks base tasks and denote them by ${\hat{\mathcal{M}}}\equiv\{M_{1},M_{2},...,M_{D}\}\subset\mathcal{M}^{\phi}$. The multi-task problem thus consists in solving the approximations

[TABLE]

where ${r}_{i}$ is the reward of $M_{i}$ (Caruana, 1997; Baxter, 2000).

In this section we argue that (9) can be replaced by a much simpler approximation problem. Suppose for a moment that we know a function $\boldsymbol{\mathrm{\phi}}$ and $D$ vectors $\boldsymbol{\mathrm{w}}_{i}$ that satisfy (9) exactly. If we then stack the vectors $\boldsymbol{\mathrm{w}}_{i}$ to obtain a matrix $\boldsymbol{\mathrm{W}}\in\mathbb{R}^{D\times d}$, we can write $\boldsymbol{\mathrm{r}}(s,a,s^{\prime})=\boldsymbol{\mathrm{W}}\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})$, where the ith element of ${\boldsymbol{\mathrm{r}}}(s,a,s^{\prime})\in\mathbb{R}^{D}$ is $r_{i}(s,a,s^{\prime})$. Now, as long as we have $d$ linearly independent tasks $\boldsymbol{\mathrm{w}}_{i}$, we can write $\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})=(\boldsymbol{\mathrm{W}}^{\top}\boldsymbol{\mathrm{W}})^{-1}\boldsymbol{\mathrm{W}}^{\top}\boldsymbol{\mathrm{r}}(s,a,s^{\prime})=\boldsymbol{\mathrm{W}}^{{\dagger}}\boldsymbol{\mathrm{r}}(s,a,s^{\prime})$. Since $\boldsymbol{\mathrm{\phi}}$ is given by a linear transformation of $\boldsymbol{\mathrm{r}}$, any task representable by the former can also be represented by the latter. To see why this is so, note that for any task in $\mathcal{M}^{\phi}$ we have $r(s,a,s^{\prime})=\boldsymbol{\mathrm{w}}^{\top}\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})=\boldsymbol{\mathrm{w}}^{\top}\boldsymbol{\mathrm{W}}^{{\dagger}}\boldsymbol{\mathrm{r}}(s,a,s^{\prime})=(\boldsymbol{\mathrm{w}}^{\prime})^{\top}\boldsymbol{\mathrm{r}}(s,a,s^{\prime})$. Therefore, we can use the rewards $\boldsymbol{\mathrm{r}}$ themselves as features, which means that we can replace (9) with the much simpler approximation

[TABLE]

One potential drawback of directly approximating ${\boldsymbol{\mathrm{r}}}(s,a,s^{\prime})$ is that we no longer have the flexibility of distinguishing between $d$, the dimension of the environment $\mathcal{M}^{\phi}$, and $D$, the number of base tasks in ${\hat{\mathcal{M}}}$. Since in general we will solve (9) or (10) based on data, having $D>d$ may lead to a better approximation. On the other hand, using $\tilde{\boldsymbol{\mathrm{r}}}(s,a,s^{\prime})$ as features has a number of advantages that in many scenarios of interest should largely outweigh the loss in flexibility.

One such advantage becomes clear when we look at the scenario above from a different perspective. Instead of assuming we know a $\boldsymbol{\mathrm{\phi}}$ and a $\boldsymbol{\mathrm{W}}$ that satisfy (9), we can note that, given any set of $D$ tasks $r_{i}(s,a,s^{\prime})$, $k\leq D$ of them will be linearly independent. Thus, the reasoning above applies without modification. Specifically, if we use the tasks’s rewards as features, as in (10), we can think of them as inducing a $\boldsymbol{\mathrm{\phi}}(s,a,s^{\prime})\in\mathbb{R}^{k}$—and, as a consequence, an environment $\mathcal{M}^{\phi}$. This highlights a benefit of replacing (9) with (10): the fact that we can work directly in the space of tasks, which in many cases may be more intuitive. When we think of $\boldsymbol{\mathrm{\phi}}$ as a non-observable, abstract, quantity, it can be difficult to define what exactly the base tasks should be. In contrast, when we look at ${\boldsymbol{\mathrm{r}}}$ directly the question we are trying to answer is: is it possible to approximate the reward function of all tasks of interest as a linear combination of the functions ${r}_{i}$? As one can see, the set ${\hat{\mathcal{M}}}$ works exactly as a basis, and thus the name “base tasks”.

Another interesting consequence of using an approximation $\tilde{\boldsymbol{\mathrm{\phi}}}(s,a,s^{\prime})\approx{\boldsymbol{\mathrm{r}}}(s,a,s^{\prime})$ as features is that the resulting SFs are nothing but ordinary action-value functions. Specifically, the jth component of $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}(s,a)$ is simply $\tilde{Q}^{\pi_{i}}_{j}(s,a)$. Next we discuss how this gives rise to a simple approach that can be combined with deep learning in a stable way.

4 Transfer in deep reinforcement learning

As described in the introduction, we are interested in using SF & GPI to build scalable agents that can be combined with deep learning in a stable way. Since deep learning generally involves vast amounts of data whose storage is impractical, we will be mostly focusing on methods that work online. As a motivating example for this section we show in Algorithm 1 how SFs and GPI can be combined with Watkins & Dayan’s (1992) $Q$-learning.111We use $x\xleftarrow{\alpha}y$ meaning $x\leftarrow x+\alpha y$. We also use $\nabla_{\boldsymbol{\mathrm{\theta}}}f(x)$ to denote the gradient of $f(x)$ with respect to the parameters $\boldsymbol{\mathrm{\theta}}$.

Algorithm 1 differs from standard $Q$-learning in two main ways. First, instead of selecting actions based on the value function being learned, the behaviour of the agent is determined by GPI (line 8). Depending on the set of SFs $\tilde{\Psi}$ used by the algorithm, this can be a significant improvement over the greedy policy induced by $\tilde{Q}^{\pi_{n+1}}$, which usually is the main determinant of a $Q$-learning agent’s behaviour.

Algorithm 1 also deviates from conventional $Q$-learning in the way a policy is learned. There are two possibilities here. One of them is for the agent to rely exclusively on the GPI policy computed over $\tilde{\Psi}$ (when the variable $\mathrm{extend\_basis}$ is set to false). In this case no specialised policy is learned for the current task, which reduces the RL problem to the supervised problem of determining $\tilde{\boldsymbol{\mathrm{w}}}$ (solved in line 10 as a least-squares regression).

Another possibility is to use data collected by the GPI policy to learn a policy $\pi_{n+1}$ specifically tailored for the task. As shown in lines 14 and 15, this comes down to solving equation (5). When $\pi_{n+1}$ is learned the function $\tilde{Q}^{\pi_{n+1}}(s,a)=\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{n+1}}(s,a)^{\top}\tilde{\boldsymbol{\mathrm{w}}}$ also takes part in GPI. This means that, if the approximations $\tilde{Q}^{\pi_{i}}(s,a)$ are reasonably accurate, the policy computed by Algorithm 1 should be strictly better than $Q$-learning’s counterpart. The SFs $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{n+1}}$ can then be added to the set $\tilde{\Psi}$, and therefore a subsequent execution of Algorithm 1 will result in an even stronger agent. The ability to build and continually refine a set of skills is widely regarded as a desirable feature for continual (or lifelong) learning (Thrun, 1996).

4.1 Challenges involved in building features

In order to use Algorithm 1, or any variant of the SF & GPI framework, we need the features $\tilde{\boldsymbol{\mathrm{\phi}}}(s,a,s^{\prime})$. A natural way of addressing the computation of $\tilde{\boldsymbol{\mathrm{\phi}}}(s,a,s^{\prime})$ is to see it as a multi-task problem, as in (9). We now discuss the difficulties involved in solving this problem online at scale.

The solution of (9) requires data coming from $D$ base tasks. In principle, we could look at the collection of sample transitions as a completely separate process. However, here we are assuming that the base tasks ${\hat{\mathcal{M}}}$ are part of the RL problem, that is, we want to collect data using policies that are competent in ${\hat{\mathcal{M}}}$. In order to maximise the potential for transfer, while learning the policies $\pi_{i}$ for the base tasks $M_{i}$ we should also learn the associated SFs $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$; this corresponds to building the initial set $\tilde{\Psi}$ used by Algorithm 1. Unfortunately, learning value functions in the form (2.2) while solving (9) can be problematic. Since the SFs $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$ depend on $\tilde{\boldsymbol{\mathrm{\phi}}}$, learning the former while refining the latter can clearly lead to undesirable solutions (this is akin to having a non-stationary reward function). On top of that, the computation of $\tilde{\boldsymbol{\mathrm{\phi}}}$ itself depends on the SFs $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$, for they ultimately define the data distribution used to solve (9). This circular dependency can make the process of concurrently learning $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$ unstable—something we observed in practice.

One possible solution is to use a conventional value function representation while solving (9) and only learn SFs for the subsequent tasks (Barreto et al., 2017). This has the disadvantage of not reusing the policies learned in ${\hat{\mathcal{M}}}$ for transfer. Alternatively, one can store all the data and learn the SFs associated with the base tasks only after $\tilde{\boldsymbol{\mathrm{\phi}}}$ has been learned, but this may be difficult in scenarios involving large amounts of data. Besides, any approximation errors in $\tilde{\boldsymbol{\mathrm{\phi}}}$ will already be reflected in the initial $\tilde{\Psi}$ computed in ${\hat{\mathcal{M}}}$.

4.2 Learning features online while retaining transferable knowledge

To recapitulate, we are interested in solving $D$ base tasks $M_{i}$ and, while doing so, build $\tilde{\boldsymbol{\mathrm{\phi}}}$ and the initial set $\tilde{\Psi}$ to be used by Algorithm 1. We want $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\Psi}$ to be learned concurrently, so we do not have to store transitions, and preferably $\tilde{\Psi}$ should not reflect approximation errors in $\tilde{\boldsymbol{\mathrm{\phi}}}$.

We argue that one can accomplish all of the above by replacing (9) with (10), that is, by directly approximating ${\boldsymbol{\mathrm{r}}}(s,a,s^{\prime})$, which is observable, and adopting the resulting approximation as the features $\tilde{\boldsymbol{\mathrm{\phi}}}$ required by Algorithm 1.

As discussed in Section 3.2, when using rewards as features the resulting SFs are collections of value functions: $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}=\tilde{\boldsymbol{\mathrm{Q}}}^{\pi_{i}}\equiv[\tilde{Q}^{\pi_{i}}_{1},\tilde{Q}^{\pi_{i}}_{2},...,\tilde{Q}^{\pi_{i}}_{D}]$. This leads to a particularly simple way of building the features $\tilde{\boldsymbol{\mathrm{\phi}}}$ while retaining transferable knowledge in $\tilde{\Psi}$. Given a set of $D$ base tasks $M_{i}$, while solving them we only need to carry out two extra operations: compute approximations $\tilde{r}_{i}(s,a,s^{\prime})$ of the functions ${r}_{i}(s,a,s^{\prime})$, to be used as $\tilde{\boldsymbol{\mathrm{\phi}}}$, and evaluate the resulting policies on all tasks—i.e., compute $\tilde{Q}^{\pi_{i}}_{j}$—to build $\tilde{\Psi}$.

Before providing a practical method to compute $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\Psi}$, we note that, although the approximations $\tilde{r}_{i}(s,a,s^{\prime})$ can be learned independently from each other, the computation of $\tilde{\boldsymbol{\mathrm{Q}}}^{\pi_{i}}$ requires policy $\pi_{i}$ to be evaluated under different reward signals. This can be accomplished in different ways; here we assume that the agent is able to interact with the tasks $M_{i}$ in parallel. We can consider that at each transition the agent observes rewards from all the base tasks, ${\boldsymbol{\mathrm{r}}}\in\mathbb{R}^{D}$, or a single scalar ${r}_{i}$ associated with one of them. We will assume the latter, but our solution readily extends to the scenario where the agent simultaneously observes $D$ tasks.

Algorithm 2 shows a possible way of implementing our solution, again using $Q$-learning as the basic RL method. We highlight the fact that GPI can already be used in this phase, as shown in line 5, which means that the policies $\pi_{i}$ can “cooperate” to solve each task $M_{i}$.

Note that if we were to learn general $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}(s,a)$ and $\tilde{\boldsymbol{\mathrm{\phi}}}(s,a,s^{\prime})$ in parallel we would necessarily have to use the latter to update the former, which means computing an approximation on top of another (see (5)). In contrast, when learning $\tilde{Q}^{\pi_{i}}_{j}(s,a)$ we can use the actual rewards ${r}_{j}(s,a,s^{\prime})$, as opposed to the approximations $\tilde{r}_{j}(s,a,s^{\prime})$ (line 10 of Algorithm 2). This means that $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\Psi}$ can be learned concurrently without the accumulation of approximation errors in $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$, as promised.

5 Experiments

In this section we use experiments to assess whether the proposed approach can indeed promote transfer on large-scale domains. Here we focus on what we consider the most relevant aspects of our experiments; for further details and additional results please see the supplementary material.

5.1 Environment

The environment we consider is conceptually similar to one of the problems used by Barreto et al. (2017) to evaluate their framework: the agent has to navigate in a room picking up desirable objects while avoiding undesirable ones. Here the problem is tackled in a particularly challenging format: instead of observing the state $s_{t}$ at time step $t$, as in the original experiments, the agent interacts with the environment from a first-person perspective, only receiving as observation a $84\times 84$ image $o_{t}$ that is insufficient to disambiguate the actual underlying state of the MDP (see Figure 1(a)).

We used Beattie et al.’s (2016) DeepMind Lab platform to design our 3D environment, which works as follows. The agent finds itself in a room full of objects of different types. There are five instances of each object type: “TV”, “ball”, “hat”, and “balloon”. Whenever the agent hits an object it picks it up and another object of the same type appears at a random location in the room. This process goes on for a minute, after which a new episode starts.

The type of an object determines the reward associated with it; thus, a task is defined (and can be referred to) by four numbers indicating the rewards attached to each object type. For example, in task 1-100 the agent is interested in objects of the first type and should avoid objects of the second type, while the other object types are irrelevant. We defined base tasks that will be used by Algorithm 2 to build $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\Psi}$ (see Figure 1(b)). The transfer ability of the algorithms will be assessed on different, unseen, tasks, referred to as test tasks.

5.2 Agents

The SF & GPI agent adopted in the experiments is a variation of Algorithms 1 and 2 that uses Watkins’s (1989) $Q(\lambda)$ to apply $Q$-learning with eligibility traces. The functions $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\Psi}$ are computed by a deep neural network whose architecture is shown in Figure 2. The network is composed of three parts. The first one uses the history of observations and actions up to time $t$, $h_{t}$, to compute a state signal $\tilde{s}_{t}=f(h_{t})$. The construction of $\tilde{s}_{t}$ can itself be broken into two stages corresponding to specific functional modules: a convolutional network (CNN) to handle the pixel-based observation $o_{t}$ and a long short-term network (LSTM) to compute $f(h_{t})$ in a recursive way (LeCun et al., 1998; Hochreiter & Schmidhuber, 1997). The second part of the network is composed of $D+1$ specialised blocks that receive $\tilde{s}_{t}$ as input and compute $\tilde{\boldsymbol{\mathrm{\phi}}}(\tilde{s}_{t},a)$ and $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}(\tilde{s}_{t},a)$ for all $a\in\mathcal{A}$. Each one of these blocks is a multilayer perceptron (MLP) with a single hidden layer (Rumelhart et al., 1986). The third part of the network is simply $\tilde{\boldsymbol{\mathrm{w}}}$, which combined with $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$ will provide the final approximations.

The entire architecture was trained end-to-end through Algorithm 2 using the base tasks shown in Figure 1(b). After the SF & GPI agent had been trained it was tested on a test task, now using Algorithm 1 with the newly-learned $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\Psi}$. In order to handle the large number of sample trajectories needed in our environment both Algorithms 1 and 2 used the IMPALA distributed architecture (Espeholt et al., 2018).

Algorithm 1 was run with and without the learning of a specialised policy (controlled via the variable $\mathrm{extend\_basis}$). We call the corresponding versions of the algorithm “SF & GPI-continual” and “SF & GPI-transfer”, respectively. We compare SF & GPI with baseline agents that use the same network architecture, learning algorithm, and distributed data processing. The only difference is in the way the network shown in Figure 2 is updated and used during the test phase. Specifically, we ignore the MLPs used to compute $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$ and instead add another MLP, with the exact same architecture, to be jointly trained with $\tilde{\boldsymbol{\mathrm{w}}}$ through $Q(\lambda)$. We then distinguish three baselines. The first one uses the state signal $\tilde{s}_{t}=f(h_{t})$ learned in the base tasks to compute an approximation $\tilde{Q}(\tilde{s},a)$—that is, both the CNN and the LSTM are fixed. We will refer to this method simply as $Q(\lambda)$. The second baseline is allowed to modify $f(h_{t})$ during test, so we call it “$DQ(\lambda)$ fine tuning” as a reference to its deep architecture. Finally, the third baseline, “$DQ(\lambda)$ from scratch”, learns its own representation $f(h_{t})$.

5.3 Results and discussion

Figure 3 shows the results of SF & GPI and the baselines on a selection of test tasks. The first thing that stands out in the figures is the fact that SF & GPI-transfer learns very good policies for the test tasks almost instantaneously. In fact, as this version of the algorithm is solving a simple supervised learning problem, its learning progress is almost imperceptible at the scale the RL problem unfolds. Since the baselines are solving the full RL problem, in some tasks their performance eventually reaches, or even surpasses, that of the transferred policies. SF & GPI-continual combines the desirable properties of both SF & GPI-transfer and the baselines. On one hand, it still benefits from the instantaneous transfer promoted by SF & GPI. On the other hand, its performance keeps improving, since in this case the transferred policy is used to learn a policy specialised to the current task. As a result, SF & GPI-continual outperforms the other methods in almost all of the tasks.222A video of SF & GPI-transfer is included as a supplement, and can also be found on this link: https://youtu.be/-dTnqfwTRMI.

Another interesting trend shown in Figures 3 is the fact that SF & GPI performs well on test tasks with negative rewards—in some cases considerably better than the alternative methods—, even though the agent only experienced positive rewards in the base tasks. This is an indication that the transferred GPI policy is combining the policies $\pi_{i}$ for the base tasks in a non-trivial way (line 8 of Algorithm 1).

In this paper we argue that SF & GPI can be applied even if assumption (2) is not strictly satisfied. In order to illustrate this point, we reran the experiments with SF & GPI-transfer using a set of linearly-depend base tasks, ${\hat{\mathcal{M}}}^{\prime}\equiv\{{\tt 1000},{\tt 0100},{\tt 0011},{\tt 1100}\}$. Clearly, ${\hat{\mathcal{M}}}^{\prime}$ can only represent tasks in which the rewards associated with the third and fourth object types are the same. We thus fixed the rewards associated with the first two object types and compared the results of SF & GPI-transfer using ${\hat{\mathcal{M}}}$ and ${\hat{\mathcal{M}}}^{\prime}$ on several tasks where this is not the case. The comparison is shown in Figure 4. As shown in the figure, although using a linearly-dependent set of base tasks does hinder transfer in some cases, in general it does not have a strong impact on the results. This smooth degradation of the performance is in accordance with Proposition 1.

The result above also illustrates an interesting distinction between the space of reward functions and the associated space of policies. Although we want to be able to represent the reward functions of all tasks of interest, this does not guarantee that the resulting GPI policy will perform well. To see this, suppose we replace the positive rewards in ${\hat{\mathcal{M}}}$ with negative ones. Clearly, in this case we would still have a basis spanning the same space of rewards; however, since now a policy that stands still is optimal in all tasks $M_{i}$, we should not expect GPI to give rise to good policies in tasks with positive rewards. One can ask how to define a “behavioural basis” that leads to good policies across $\mathcal{M}$ through GPI. We leave this as an interesting open question.

6 Related work

Recently, there has been a resurgence of the subject of transfer in the deep RL literature. Teh et al. (2017) propose an approach for the multi-task problem—which in our case is the learning of base tasks—that uses a shared policy as a regulariser for specialised policies. Finn et al. (2017) propose to achieve fast transfer, which is akin to SF & GPI-transfer, by focusing on adaptability, rather than performance, during learning. Rusu et al. (2016) and Kirkpatrick et al. (2016) introduce neural-network architectures well-suited for continual learning. There have also been previous attempts to combine SFs and deep learning for transfer, but none of them used GPI (Kulkarni et al., 2016; Zhang et al., 2016).

Many works on the combination of deep RL and transfer propose modular network architectures that naturally induce a decomposition of the problem (Devin et al., 2016; Heess et al., 2017; Clavera et al., 2017). Among these, a recurrent theme is the existence of sub-networks specialised in different skills that are managed by another network (Heess et al., 2016; Frans et al., 2017; Oh et al., 2017). This highlights an interesting connection between transfer learning and hierarchical RL, which has also recently re-emerged in the deep RL literature (Vezhnevets et al., 2017; Bacon et al., 2017).

7 Conclusion

In this paper we extended the SF & GPI transfer framework in two ways. First, we showed that the theoretical guarantees supporting the framework can be extended to any set of MDPs that only differ in the reward function, regardless of whether their rewards can be computed as a linear combination of a set of features or not. In order to use SF & GPI in practice we still need the reward features, though; our second contribution is to show that these features can be the reward functions of a set of MDPs. This reinterpretation of the problem makes it possible to combine SF & GPI with deep learning in a stable way. We empirically verified this claim on a complex 3D environment that requires hundreds of millions of transitions to be solved. We showed that, by turning an RL task into a supervised learning problem, SF & GPI-transfer is able to provide skilful, non-trivial, policies almost instantaneously. We also showed how these policies can be used by SF & GPI-continual to learn specialised policies, which can then be added to the agent’s set of skills. Together, these concepts can help endow an agent with the ability to build, refine, and use a set of skills while interacting with the environment.

Acknowledgements

The authors would like to thank Will Dabney and Hado van Hasselt for the invaluable discussions during the development of this paper. We also thank the anonymous reviewers, whose comments and suggestions helped to improve the paper considerably.

Appendix A Proof of theoretical results

We restate Barreto et al.’s (2017) GPI theorem to be used as a reference in the derivations that follow.

Theorem 1**.**

(Generalized Policy Improvement)* Let $\pi_{1}$, $\pi_{2}$, …, $\pi_{n}$ be $n$ decision policies and let $\tilde{Q}^{\pi_{1}}$, $\tilde{Q}^{\pi_{2}}$, …, $\tilde{Q}^{\pi_{n}}$ be approximations of their respective action-value functions such that*

[TABLE]

Define

[TABLE]

Then,

[TABLE]

for any $s\in S$ and any $a\in A$, where $Q^{\pi}$ is the action-value function of ${\pi}$.

Lemma 1**.**

Let $\delta_{ij}=\max_{s,a}\left|r_{i}(s,a)-r_{j}(s,a)\right|$ and let $\pi$ be an arbitrary policy. Then,

[TABLE]

Proof.

Define $\Delta_{ij}=\max_{s,a}|Q_{i}^{\pi}(s,a)-Q^{\pi}_{j}(s,a)|$. Then,

[TABLE]

Since (A) is valid for any $s,a\in S\times A$, we have shown that $\Delta_{ij}\leq\delta_{ij}+\gamma\Delta_{ij}$. Solving for $\Delta_{ij}$ we get

[TABLE]

∎

Lemma 2**.**

Let $\delta_{ij}=\max_{s,a}\left|r_{i}(s,a)-r_{j}(s,a)\right|$. Then,

[TABLE]

Proof.

To simplify the notation, let $Q^{i}_{i}(s,a)\equiv Q_{i}^{\pi^{*}_{i}}(s,a)$. Note that $|Q_{i}^{i}(s,a)-Q^{j}_{j}(s,a)|$ is the difference between the value functions of two MDPs with the same transition function but potentially different rewards. Let $\Delta_{ij}=\max_{s,a}|Q_{i}^{i}(s,a)-Q^{j}_{j}(s,a)|$. Then,

[TABLE]

Since (A) is valid for any $s,a\in S\times A$, we have shown that $\Delta_{ij}\leq\delta_{ij}+\gamma\Delta_{ij}$. Solving for $\Delta_{ij}$ we get

[TABLE]

∎

Proposition 1**.**

Let $M\in\mathcal{M}$ and let $Q^{\pi_{j}^{*}}_{i}$ be the action-value function of an optimal policy of $M_{j}\in\mathcal{M}$ when executed in $M_{i}\in\mathcal{M}$. Given approximations $\{\tilde{Q}^{\pi_{1}}_{i},\tilde{Q}^{\pi_{2}}_{i},...,\tilde{Q}^{\pi_{n}}_{i}\}$ such that $\left|Q^{\pi_{j}^{*}}_{i}(s,a)-\tilde{Q}^{\pi_{j}}_{i}(s,a)\right|\leq\epsilon$ for all $s\in\mathcal{S}$, $a\in\mathcal{A}$, and $j\in\{1,2,...,n\}$, let

[TABLE]

Then,

[TABLE]

where $Q^{*}$ is the optimal value function of $M$, $Q^{\pi}$ is the value function of $\pi$ in $M$, and $\|f-g\|_{\infty}=\max_{s,a}|f(s,a)-g(s,a)|$.

Proof.

The result is a direct application of Theorem 1 and Lemmas 1 and 2. Let $\pi^{*}$ be an optimal value function of $M$. Then,

[TABLE]

From Lemma 2, we know that

[TABLE]

From Theorem 1 we know that, for any $j\in\{1,2,...,n\}$, we have

[TABLE]

Finally, from Lemma 1, we know that

[TABLE]

∎

Appendix B Details of the experiments

In this section we give details of the experiments that had to be left out of the main paper due to the space limit.

B.1 Agents’s architecture

The CNN used in Figure 2 is identical to that used by Mnih et al.’s (2015) DQN. The CNN outputs a $256$-dimensional vector that serves as the LSTM state. As shown in Figure 2, the LSTM also receives the previous action of the agent as an input. The output of the LSTM is a vector of dimension $256$, which in the paper we call the state signal $\tilde{s}$. The vector $\tilde{s}$ is the input of the $D+1$ MLPs used to compute $\tilde{\boldsymbol{\mathrm{\phi}}}$ and $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$. These MLPs have $100$ $\tanh$ hidden units and an output of dimension $D\times|\mathcal{A}|$—that is, for each action $a\in\mathcal{A}$ the MLP outputs a $D$-dimensional vector representing either $\tilde{\boldsymbol{\mathrm{\phi}}}$ or one of the $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{i}}$. These $D$-dimensional vectors are then multiplied by $\tilde{\boldsymbol{\mathrm{w}}}$, leading to a $(D+1)\times|\mathcal{A}|$ output representing $\tilde{r}$ and $\tilde{Q}^{\pi_{i}}$.

B.2 Agents’s training

The losses shown in lines 10 and 14 of Algorithm 1 and in lines 7 and 10 of Algorithm 2 were minimised using the RMSProp method, a variation of the well-known back-propagation algorithm. As parameters of RMSProp we adopted a fixed decay rate of $0.99$ and $\epsilon=0.01$. For all algorithms we tried at least two values for the learning rate: $0.01$ and $0.001$. For the baselines “$DQ(\lambda)$ fine tuning” and “$DQ(\lambda)$ from scratch” we also tried a learning rate of $0.005$. The results shown in the paper are those associated with the best final performance of each algorithm.

As mentioned in the paper, the agents’s training was carried out using the IMPALA architecture (Espeholt et al., 2018). In IMPALA the agent is conceptually divided in two groups: “actors”, which interact with the environment in parallel collecting trajectories and adding them to a queue, and a “learner”, which pulls trajectories from the queue and uses them to apply the updates. On the learner side, we adopted a simplified version of IMPALA that uses $Q(\lambda)$ as the RL algorithm (i.e., no parametric representation of policies nor off-policy corrections). For the distributed collection of data we used $50$ actors per task. Each actor gathered trajectories of length $20$ that were then added to the common queue. The collection of data followed an $\epsilon$-greedy policy with a decaying $\epsilon$. Specifically, the value of $\epsilon$ started at $0.5$ and decayed linearly to $0.05$ in $10^{6}$ steps. The results shown in the paper correspond to the performance of the $\epsilon$-greedy policy (that is, they include exploratory actions of the agents).

For the results with SF & GPI-continual, in addition to the loss induced by equation (5), minimised in line 15 of Algorithm 1, we also used a standard $Q(\lambda)$ loss—that is, the gradients associated with both losses were combined through a weighted sum and then used to update $\boldsymbol{\mathrm{\theta}}_{\psi}$. The weights for the standard $Q(\lambda)$ loss and the loss computed in line 14 of Algorithm 1 were $1$ and $0.1$, respectively. Using the standard $Q(\lambda)$ loss seems to stabilise the learning of $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{n+1}}$; in this case (5) can be seen as a constraint for the standard RL optimisation. Obviously, if we want to add $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{n+1}}$ to $\tilde{\Psi}$, we have to make sure that the SF semantics is preserved—that is, the result of the combined updates approximately satisfies (5). We confirmed this fact by monitoring the loss computed in line 14 of Algorithm 1. Figure 5 shows the average of this loss computed over $10$ runs of SF & GPI-continual on all test tasks; as shown in the figure, the loss is indeed minimised, which implies that the resulting $\tilde{\boldsymbol{\mathrm{\psi}}}^{\pi_{n+1}}$ are valid SFs that can be safely added to $\tilde{\Psi}$.

B.3 Environment

The room used in the environment and illustrated in Figure 1(a) was of size $13\times 13$ (Beattie et al., 2016). The observations $o_{t}$ were an $84\times 84$ image with pixels re-scaled to the interval $[0,1]$. The action space $\mathcal{A}$ contains $8$ actions: move forward, move backwards, strafe left, strafe right, look left, look right, look left and move forward, and look right and move forward. Each action was repeated for $4$ frames, that is, the agent was allowed to choose an action at every $4$ observations (we note that the “environment steps” shown in the plots refer to actual observations, not the number of decisions made by the agent).

Appendix C Additional results

In our experiments we defined a set of $9$ test tasks in order to cover reasonably well three qualitatively distinct combinations of rewards: only positive rewards, only negative rewards, and mixed rewards. Figure 6 shows the results of SF & GPI-transfer and the baselines on the test tasks that could not be included in the paper due to the space limit.

As discussed in the paper, ideally our agent should rely on the GPI policy when useful but also be able to learn and use a specialised policy otherwise. Figures 7, 8 and  9 show that this is possible with SF & GPI-continual. Looking at Figure 7 we see that when the test task only has positive rewards the performances of SF & GPI-transfer and SF & GPI-continual are virtually the same. This makes sense, since in this case alternating between the policies $\pi_{i}$ learned on ${\hat{\mathcal{M}}}$ should lead to good performance. Although initially the specialised policy $\pi_{\mathrm{test}}$ does get selected by GPI a few times, eventually the policies $\pi_{i}$ largely dominate. The figure also corroborates the hypothesis that GPI is in general not computing a trivial policy, since even after settling on the policies $\pi_{i}$ it keeps alternating between them.

Interestingly, when we look at the test tasks with negative rewards this pattern is no longer observed. As shown in Figures 8 and 9, in this case SF & GPI-continual  eventually outperforms SF & GPI-transfer—which is not surprising. Looking at the frequency at which policies are selected by GPI, we observe the opposite trend as before: now the policy $\pi_{\mathrm{test}}$ steadily becomes the preferred one. The fact that a specialised policy is learned and eventually dominates is reassuring, as it indicates that $\pi_{\mathrm{test}}$ will contribute to the repository of skills available to the agent when added to $\tilde{\Psi}$.

As discussed in the main paper, one of the highlights of the proposed algorithm is the fact that it can use any set of base tasks and enable transfer to related, unseen, tasks. To empirically verify this claim, we tested several sets of base tasks. We used as a reference our “canonical” set of base tasks ${\hat{\mathcal{M}}}$ that spans the environment $\mathcal{M}$. We further validated our approach on a linearly-depend set of base tasks ${\hat{\mathcal{M}}}^{\prime}$ that does not span the set of (test) tasks we are interested in—these results are shown in Figure 4. In addition to these, we now present experiments with a third set of base tasks that does span the set of tasks but does not include any of the canonical tasks: ${\hat{\mathcal{M}}}^{\prime\prime}=\{{\tt(1,\text{-}0.1,\text{-}0.1,\text{-}0.1)},{\tt(\text{-}0.1,1,\text{-}0.1,\text{-}0.1)},{\tt(\text{-}0.1,\text{-}0.1,1,\text{-}0.1)},{\tt(\text{-}0.1,\text{-}0.1,\text{-}0.1,1)}\}$. In Figure 10 we report results obtained by SF & GPI-transfer, using the three sets of base tasks described, on the $9$ previously-introduced test tasks. We can see that all sets of base tasks lead to satisfactory transfer, but the performance of the transferred policy can vary significantly depending on the relation between the base tasks used and the test task. This is again an illustration of the distinction between the “reward basis” and the “behaviour basis” discussed in Section 5.3.