1 Introduction
Reinforcement learning (RL) provides a framework for the development of situated agents that learn how to behave while interacting with the environment [21]. The basic RL loop is defined in an abstract way so as to capture only the essential aspects of such an interaction: an agent receives observations and selects actions to maximize a reward signal. This setup is generic enough to describe tasks of different levels of complexity that may unroll at distinct time scales. For example, in the task of driving a car, an action can be to turn the wheel, to make a right turn, or to drive to a given location.
Clearly, from the point of view of the designer it is desirable to describe a task at the highest level of abstraction possible. However, by doing so one may overlook behavioral patterns and inadvertently make the task more difficult than it really is. The action of driving to a location clearly encompasses the action of making a right turn, which in turn encompasses the action of turning the wheel. In learning how to drive an agent should be able to identify and to exploit such interdependencies. More generally, the agent should be able to break a task in smaller subtasks and use knowledge accumulated in any subset of those to speed up learning in related tasks. This process of leveraging knowledge acquired in one task to improve performance on another task is usually referred to as transfer.
Transfer in reinforcement learning can be defined in many different ways, but in general it refers to the notion that generalization should occur not only within a task but also across tasks [23]. In this paper we look at one specific type of transfer, namely, when the subtasks involved correspond to different reward functions defined in the same environment. This setup is flexible enough to allow transfer to happen at different levels. In particular, since rewards are a generic device to define the agent’s objective, by appropriately defining them one can induce different task decompositions. For instance, the type of hierarchical decomposition involved in the driving example above can be induced by changing the frequency at which rewards are delivered to the agent: a positive reinforcement can be given after each maneuver that is well executed or only at the final destination. It is not difficult to see that one can also decompose a task in subtasks that are fairly independent of each other or whose dependency is strictly temporal (that is, when the tasks must be executed in a certain order but no single task is clearly “contained” within another).
These types of task decomposition potentially allow the agent to tackle more complex problems than would be possible were the tasks modeled as a single monolithic challenge. However, in order to exploit this structure to its full extent the agent should have an explicit mechanism to promote transfer between tasks. Ideally, we want a transfer approach to have two important properties. First, the flow of information between tasks should not be dictated by a rigid diagram that reflects the relationship between the tasks themselves, such as hierarchical or temporal dependencies. On the contrary, information should be exchanged between tasks whenever useful. Second, rather than being posed as a separate problem, transfer should be integrated into the RL framework as much as possible, preferably in a way that is almost transparent to the agent.
In this paper we propose an approach to implement transfer that has the two properties above. Our method builds on two basic ideas that complement each other. The first one is a generalization of a concept proposed by Dayan [7] called successor representation. As the name suggests, in this representation scheme each state is described by a prediction about the future occurrence of all other states under a fixed policy. We present a generalization of Dayan’s idea which extends the original scheme to continuous spaces and also facilitates the incorporation of function approximation. We call the resulting scheme successor features. As will be shown, successor features lead to a representation of the value function that naturally decouples the dynamics of the environment from the rewards, which makes them particularly suitable for transfer.
In order to actually put transfer into effect with successor features, we present two theoretical results that provide the foundation of our approach. The first one is a generalization of Bellman’s [4] classic policy improvement theorem that extends the original result from one to multiple decision policies. This result shows how knowledge about a set of tasks can be transferred to a new task in a way that is completely integrated with reinforcement learning. It also provides performance guarantees on the new task before any learning has taken place. The second theoretical result is a theorem that formalizes the notion that an agent should be able to perform well on a task if it has seen a similar task before—something clearly desirable in the context of transfer. Combined, the two results above not only set our approach in firm ground but also outline the mechanics of how to actually implement transfer. We build on this knowledge to propose a concrete method and evaluate it in experiments that illustrate the benefits of transfer in practice.
2 Background and Problem Formulation
We consider the framework of RL outlined in the introduction: an agent interacts with an environment and selects actions in order to maximize the expected amount of reward received in the long run [21]. As usual, we assume that this interaction can be modeled as a Markov decision process (MDP, Puterman, [17]). An MDP is defined as a tuple . The sets and are the state and action spaces, respectively; here we assume that and are finite whenever such an assumption facilitates the presentation, but most of the ideas readily extend to continuous spaces. For each and the function gives the nextstate distribution upon taking action in state . We will often refer to as the dynamics of the MDP. The reward received at transition is given by ; usually one is interested in the expected reward resulting from the execution of in , which is given by . The discount factor gives smaller weights to rewards received further in the future.
The goal of the agent in RL is to find a policy —a mapping from states to actions—that maximizes the expected discounted sum of rewards, also called the return One way to address this problem is to use methods derived from dynamic programming (DP), which heavily rely on the concept of a value function [17]. The actionvalue function of a policy is defined as
(1) 
where denotes expected value when following policy . Once the actionvalue function of a particular policy is known, we can derive a new policy which is greedy with respect to , that is, . Policy is guaranteed to be at least as good as (if not better than) policy . These two steps, policy evaluation and policy improvement, define the basic mechanics of RL algorithms based on DP; under certain conditions their successive application leads to an optimal policy that maximizes the expected return from every state in [21].
As mentioned, in this paper we are interested in the problem of transfer. Here we adopt the following definition: given two sets of tasks and such that , after being exposed to the agent should perform no worse, and preferably better, than it would had it been exposed to only. Note that can be the empty set. In this paper a task will be a specific reward function for a given MDP. In Section 4
we will revisit this definition and make it more formal, and we will also clarify the measure used to compare performance. Before doing that, though, we will present a core concept for this paper whose interest is not restricted to transfer learning.
3 Successor Features
In this section we present the concept that will serve as a cornerstone for the rest of the paper. We start by presenting a simple reward model and then show how it naturally leads to a generalization of Dayan’s [7] successor representation (SR).
Suppose that the onestep expected reward associated with stateaction pair is given by
(2) 
where are features of and are weights. Supposing that (2) is true is not restrictive since we are not making any assumptions about : if we have for some , for example, we can clearly recover any reward function exactly. To simplify the notation, let . Then, by simply rewriting the definition of the actionvalue function in (1) we have
(3) 
We call the successor features (SFs) of under .
The i component of gives the discounted sum of when following policy starting from . In the particular case where and are finite and is a tabular representation of —that is,
is a “onehot” vector in
— is the discounted sum of occurrences of each stateaction pair under . This is essentially the concept of SR extended from the space to the set [7]. One of the points here is precisely to generalize SR to be used with function approximation, but the exercise of deriving the concept as above provides insights already in the tabular case. To see why this is so, note that in the tabular case the entries of are the function and suppose that in only a small subset . From (2) and (3), it is clear that the cardinality of , and not of , is what effectively defines the dimension of the representation , since there is is no point in having . Although this fact is hinted at in Dayan’s [7] paper, it becomes much more apparent when we look at SR as a particular case of SFs.SFs extend Dayan’s [7] SR in two ways. First, the concept readily applies to continuous state and action spaces without any modification. Second, by explicitly casting (2) and (3) as inner products involving feature vectors, SFs make it evident how to incorporate function approximation, since these vectors can clearly be learned from data. For reasons that will become apparent shortly, in this paper we are mostly interested in learning and . The extension to the scenario where must also be learned should not be difficult, though, and will also be discussed.
The SFs are a way of summarizing the dynamics induced by in a given environment. As shown in (3), this allows for a modular representation of in which the MDP’s dynamics are decoupled from its rewards, which are captured by . One potential benefit of having such a decoupled representation is that only the relevant module must be relearned when either the dynamics or the reward changes. We come back to this point after describing how exactly each module can be learned.
The representation in (3) requires two components to be learned, and . Since the latter is the expected discounted sum of under , we either know or must learn it as well. Note that
is a supervised learning problem, so one can resort to one of the many wellunderstood techniques from the field to learn
(and potentially , too)[8]. As for , we note that(4) 
that is, SFs satisfy a Bellman equation in which play the role of rewards—something also noted by Dayan [7] regarding SR. Therefore, in principle any RL method can be used to compute [21, 6].^{1}^{1}1Yao et al. [25] discuss the properties of (3) when and are approximations learned in one specific way. However, the ideas presented here are not tightly coupled with any formulation of the two learning subproblems.
Now that we have described how to learn and , we can resume the discussion on the potential benefits of doing so. Suppose that we have learned the value function of a given policy using the scheme shown in (3). It should be clear that whenever the reward function changes we only need to learn a new . Similarly, whenever the dynamics of the MDP change we can relearn while retaining in the information that has remained the same. But SFs may be useful even if we restrict ourselves to the setting usually considered in RL, in which and are fixed. Note that the dynamics that determine , and thus , depend on both and . Hence, even when the former is fixed, the possibility of only relearning may be advantageous when is changing, as is the case in the usual RL loop, since information regarding the reward function is preserved in . This helps explain the good performance of SR in Dayan’s [7] experiments and may also serve as an argument in favor of adopting SFs as a general approximation scheme for RL. However, in this paper we focus on a scenario where the decoupled valuefunction approximation provided by SFs is exploited to its full extent, as we discuss next.
4 Transfer Via Successor Features
In this section we return to our discussion about transfer in RL. As described, we are interested in the scenario where all components of an MDP are fixed, except for the reward function. One way of formalizing this model is through (2): if we suppose that is fixed, any gives rise to a new MDP. Based on this observation, we define
(5) 
that is, is the set of MDPs induced by through all possible instantiations of . Since what differentiates the MDPs in is essentially the agent’s goal, we will refer to as a task. The assumption is that we are interested in solving (a subset of) the tasks in the environment .
Unlike (2), which is not restrictive at all, supposing that a family of tasks of interest fit in the definition (5) will in general be a restrictive assumption.^{2}^{2}2It is not restrictive when is greater than or equal to the number of MDPs we are interested in or when . In the first case we can simply make the i dimension of equal to the reward function of the i MDP. As for the second case, if we can afford to use SR—that is, if — will include all possible reward functions over . Despite the fact that similar assumptions have been made in the literature [1], we now describe some illustrative examples that suggest that our formulation of is a natural way of modeling some scenarios of interest.
Perhaps the best way to motivate (5
) is to note that some aspects of real environments which we clearly associate with specific features change their appeal over time. Think for example how much the desirability of water or food changes depending on whether an animal is thirsty or hungry. One way to model this type of preference shifting, which should probably occur with some types of artificial agents as well, is to suppose that the vector
appearing in (2) reflects the taste of the agent at any given point in time. For a more concrete example, imagine that the agent’s goal is to produce and sell a combination of goods whose production line is relatively stable but whose prices vary considerably over time. In this case updating the price of the products corresponds to picking a new . Another intuitive example, which we will explore in the experimental section, is to imagine that the agent is navigating in a fixed environment but the goal location changes from time to time.In all the examples above it is desirable for the agent to build on previous experience to improve its performance on a new setup. More concretely, if the agent knows good policies for the set of tasks , with , it should be able to leverage this knowledge somehow to improve its behavior on a new task —that is, it should perform better than it would had it been exposed to only a subset of the original tasks, . Here we assess the performance of an agent on based on the value function of the policy computed by the agent after receiving the new but before any learning has taken place in .^{3}^{3}3Of course can, and will be, learned, as discussed in Section 4.2 and illustrated in Section 5. Here though we assume that is given to make the definition of our performance criterion as clear as possible. More precisely, suppose that an agent has performed a number of transitions in each one of the tasks . Based on this experience and on the new , computes a policy that will define its initial behavior in . Now, if we repeat the experience replacing with , the value of the resulting policy should be such that for all and all .
Now that our setup is clear we can start to describe our solution for the transfer problem described above. We do so in two stages. First, we present a generalization of DP’s notion of policy improvement whose interest may go beyond the current work. We then show how SFs can be used to implement this generalized form of policy improvement in an efficient and elegant way.
4.1 Generalized Policy Improvement
One of the key results in DP is Bellman’s [4] policy improvement theorem. Basically, the theorem states that acting greedily with respect to a policy’s value function gives rise to another policy whose performance is no worse than the former’s. This is the driving force behind DP, and any RL algorithm that uses the notion of a value function is exploiting Bellman’s result in one way or another.
In this section we extend the policy improvement theorem to the scenario where the new policy is to be computed based on the value functions of a set of policies. We show that this extension can be done in a very natural way, by simply acting greedily with respect to the maximum over the value functions available. Our result is summarized in the theorem below.
Theorem 1.
(Generalized Policy Improvement) Let , , …, be decision policies and let , , …, be approximations of their respective actionvalue functions such that
(6) 
Define Then,
(7) 
for any and any , where is the actionvalue function of .
The proofs of our theoretical results are in Appendix A. As one can see, our theorem covers the case in which the policies’ value functions are not computed exactly, either because function approximation is used or because some exact algorithm has not be run to completion. This error is captured by in (6), which of course reappears as a “penalty” term in the lower bound (7). Such a penalty is inherent to the presence of approximation in RL, and in fact it is identical to the penalty incurred in the singlepolicy case (see e.g. Bertsekas and Tsitsiklis’s Proposition 6.1 [5]).
In order to contextualize our result within the broader scenario of DP, suppose for a moment that
. In this case Theorem 1 states that will perform no worse than all of the policies , . This is interesting because in general —the function used to induce —is not the value function of any particular policy. It is not difficult to see that will be strictly better than all previous policies if for any , that is, if no single policy dominates all other policies. If one policy does dominate all others, Theorem 1 reduces to the original policy improvement theorem. Note that this will always be the case if one of the optimal policies belongs to the set , .If we consider the usual DP loop, in which policies of increasing performance are computed in sequence, our result is not of much use because the most recent policy will always dominate all others. Another way of putting it is to say that after Theorem 1 is applied once adding the resulting to the set , will reduce the next improvement step to standard policy improvement, and thus the policies , can be simply discarded.
There are however two situations in which our result may be of interest. One is when we have many policies being evaluated in parallel. In this case Theorem 1 provides a principled strategy for combining these policies. This could be used for example as an initialization scheme for policy iteration when it is possible to evaluate many policies simultaneously. This possibility may also be useful in RL when one consider the multiagent setting. The other situation in which our result may be useful is when the underlying MDP changes, as we discuss next.
4.2 Generalized Policy Improvement with Successor Features
We start this section by extending our notation slightly to make it easier to refer to the quantities involved in transfer learning. Let be a task in defined by . We will use to refer to an optimal policy of MDP and use to refer to its value function. The value function of when executed in will be denoted by .
Suppose now that an agent has computed optimal policies for the tasks . Suppose further that when exposed to a new task the agent computes —the value functions of the policies under the new reward function induced by . In this case, applying Theorem 1 to the newlycomputed set of value functions will give rise to a policy that performs at least as well as a policy computed based on any subset of the set above, including the empty set (except of course in the unlikely event that one starts with a randomlygenerated policy that performs well). Thus, this strategy satisfies our definition of successful transfer.
There is a caveat, though. Why would one waste time computing the value functions of , …, , whose performance in may be mediocre, if the same amount of resources can be allocated to compute a sequence of policies with increasing performance? This is where SFs come into play. Suppose that we have learned the functions using the approximation scheme shown in (3). Now, if the reward changes to , as long as we have we can compute the new value function of by simply making . This reduces the computation of all to the much simpler supervised learning problem of computing .
Once have been computed, we can apply Theorem 1 to derive a policy whose performance on is no worse than the performance of on the same task. A question that arises in this case is whether we can provide stronger guarantees on the performance of by exploiting the structure shared by the tasks in . The following theorem answers this question in the affirmative.
Theorem 2.
Let and let be the value function of an optimal policy of when executed in . Given approximations such that
(8) 
let Finally, let , where is the norm induced by the inner product adopted. Then,
(9) 
Note that we used “” rather than “” in the theorem’s statement to remove any suggestion of order among the tasks. This also makes it explicit that the result also applies when . Theorem 2 is a specialization of Theorem 1 for the case where the set of value functions used to compute are associated with tasks in the form of (5). As such, it provides stronger guarantees than its precursor: instead of comparing the performance of with that of the previouslycomputed policies , Theorem 2 quantifies the loss incurred by following as opposed to of one of ’s optimal policies.
As shown in (9), the loss is upperbounded by two terms. As before, is a “penalty” term that shows up in the bound due to the use of approximations instead of the true value functions . The term is of more interest here because it reflects the structure of . This term is a multiple of the distance between , the vector describing the task we are currently interested in, and the closest for which we have computed a policy. This formalizes the intuition that the agent should perform well in task if it has solved a similar task before. More generally, the term in question relates the concept of distance in with difference in performance in , which allows for interesting extrapolations. For example, if we assume that the tasks are sampled from a distribution over , it might be possible to derive probabilistic performance guarantees whose probability of failure goes to zero as .
Although Theorem 2 is inexorably related to the characterization of in (5), it does not depend on the definition of SFs in any way. Here SFs are the mechanism used to efficiently apply the protocol suggested by Theorem 2. When SFs are used the value function approximations are given by . The modules are computed and stored when the agent is learning the tasks ; when faced with a new task the agent computes an approximation of , which is a supervised learning problem, and then uses the policy defined in Theorem 2 to learn . Note that we do not assume that either or is computed exactly: the effect of errors in and in the approximation of is accounted for by the term appearing in (8). As shown in (9), if is small and the agent has seen enough tasks the performance of on should already be good, which suggests that it will also speed up the process of learning . In the next section we verify empirically how these effects manifest in practice.
5 Experiments
In this section we use experiments to illustrate how the transfer promoted by the combination of generalized policy iteration and SFs actually takes place in practice. In order to do so we introduce a generalized version of a classic RL task known as the “puddle world” [20]. The puddle world is a simple twodimensional problem with a goal position and two elliptical “puddles,” one vertical and one horizontal [20]. The four actions available move the agent up, down, left, or right. An action fails with probability , in which case an action selected uniformly at random is executed. The objective is to reach the goal while avoiding the puddles along the way.
We generalized the puddle world task by letting the position of the puddles and of the goal state to change at arbitrary time steps. More specifically, we implemented the task as a grid and restricted the position of the elements to a subset of the cells: the goal is only allowed to be in one of the four corners and the two puddles are restricted to the set . This gives rise to possible configurations of the task, which is our set . Following (5), the reward function for the i task was defined as . Here is a binary vector in that indicates whether the state that most likely leads to corresponds to a puddle or a goal. Specifically, if the i entry of is associated with, say, one of the possible locations of the horizontal puddle, it will be equal to if and only if has as its most likely outcome the state at that location. The goal and puddles that are present in the i task are indicated by three nonzero elements in : a entry associated with the goal and a entry associated with each puddle.
We focus on the online RL scenario where the agent must learn while interacting with the environment . The task changes at every transitions, with a new selected uniformly at random from the set described above. We adopted Watkins and Dayan’s [24] learning as our basic algorithm and combined it with different representation schemes to show their potential for transfer. In particular, we compared four versions of learning: using a tabular representation (QL), using a tabular representation that is reinitialized to zero whenever the task changes (QLR), using SR, and using SFs. All versions of the algorithm used an greedy policy to explore the environment, with [21].
The SR and SF agents were implemented in the following way. The actionvalue function was represented as , where is associated with the i task. Both and were learned online. The former was learned using temporaldifference updates to solve (4) [21], while the latter was learned as a leastsquares minimization of the difference between the two sides of (2). Every time the task changed the current was stored, a new was created, and was reinitialized to . The agent followed a greedy policy with respect to (hence the policy that induces (4) was constantly changing). In the case of SR, were vectors in , as usual (here ). The SF agent received with each the corresponding vector . So, in this case .
The results of our experiments are shown in Figure 1. Several interesting observations can be made regarding the figure. First, note that QLR is unable to learn the task. If we compare it with QL, the difference in performance suggests that in this environment starting from an actual value function leads to better results than starting from a function that is zero everywhere, regardless of the policy associated with . Also note that there is a clear improvement on the algorithms’ performance as the interval to change the reward increases, which is not surprising. However, the most important point to be highlighted here is that both SR and SF significantly outperform the standard version of learning. This is an illustration of our theoretical results and a demonstration that the proposed approach is indeed able to successfully transfer knowledge across tasks. Finally, note that SF outperforms SR by a considerable margin. This is also expected: since the former uses a vector that is in rather than in , the nonzero elements of this vector will be updated whenever the agent encounters a puddle or a goal, regardless of the specific pair that lead to that state. This shows how, unlike its precursor, SFs allows for generalization.
6 Related Work
In this paper we present SFs, a representation scheme for value functions, and show how they provide a natural framework for implementing transfer in RL. Both representation and transfer are active areas of research in RL; in what follows we briefly describe the previous work we consider to be more closely related to ours and take advantage of the relevant connections to point out some interesting directions for future research.
When it comes to representation, a lot of effort in previous research has been directed towards the development of methods to automatically compute good features to represent the value function [14, 10, 16, 15]. Many of these approaches build on the fact that, when is finite, the value function of a policy is given by , where and . The idea is to exploit the structure in the definition of to replace the set of vectors , which is infinite, by a properly defined basis whose cardinality is preferably smaller than . If we adopt the reward model in (2), we can rewrite the previous expression as , where is a vector in whose i row is . If we then define , it should be clear that the i row of is . This shows that arises as a natural basis when (2) is adopted, which is neither very surprising nor very useful, since lives in . What is perhaps more interesting is the observation that, since the definitions of and are very similar, the methods cited above could in principle also be used to find good features to represent itself.
Although the methods above decouple the construction of features from the actual RL problem, it is also possible to tackle both problems concomitantly, using general nonlinear function approximators to incrementally learn [12]. Another interesting possibility is the definition of a clear protocol to also learn , which is closely related to the problem known as “multitask feature learning” [1]. Here again the use of nonlinear approximators may be useful, since with them it may be possible to embed an arbitrary family of MDPs into a model with the structure shown in (5) [11].
Still on the subject of representation, a scheme that also relates to SFs is Littman et al.’s [9] predictive state representation (PSR). PSRs are similar to SFs in the sense that they also have a prediction at the core of their representation. Unlike the latter, though, the former tries to use such predictions to summarize the dynamics of the entire environment rather than of a single policy . A scheme that is perhaps closer to SFs is the value function representation sometimes adopted in inverse RL [13]. The scenario considered in this case is considerably different, though, since the focus is in finding a that induces a predefined policy .
We now turn our attention to previous work related to the use of SFs for transfer. As mentioned in the introduction, the problem of transfer has many definitions in the literature [23]. When we focus on the scenario considered here, in which the agent must perform well on a family of MDPs that differ only in the reward function, two approaches are possible. One of them is to learn a model of the MDPs’ dynamics [3]. Another alternative, which is more inline with our approach, is to summarize the experience using policies or value functions—which in some sense represent a “partial model” of the environment. Among these, Schaul et al.’s [18] universal value function approximators (UVFAs) are particularly relevant to our work. UVFAs extend the notion of value function to also include as an argument a representation of a goal. We note that the function used in our generalized policy improvement framework can be seen as a function of , , and —the latter a generic way of representing a “goal.” Thus, in some sense the approximation scheme proposed here is a UVFA, in which corresponds to the learned goal embedding.
As discussed, one possible interpretation of the scenario studied here is that there is one main task that has been decomposed in many subtasks. This view of transfer highlights an interesting connection between our approach and temporal abstraction. In fact, if we look at as instances of Sutton et al.’s [22] options, acting greedily with respect to the maximum over their value functions corresponds in some sense to planning at a higher level of temporal abstraction. This is the view adopted by Yao et al. [25], whose universal option model closely resembles our approach in some aspects. The main difference is that, unlike in our method, in Yao et al.’s [25] approach options are not used to learn new options.
7 Conclusion
This paper builds on two concepts, both of which are generalizations of previous ideas. The first one is SFs, a generalization of Dayan’s [7] SR that extends the original definition from discrete to continuous spaces and also facilitates the incorporation of function approximation. The second concept is generalized policy improvement, formalized in Theorem 1. As the name suggests, this result extends Bellman’s [4] classic policy improvement theorem from a single to multiple policies.
Although SFs and generalized policy improvement are of interest on their own, in this paper we focus on their combination to induce transfer. The resulting framework is an elegant extension of DP’s basic setting that provides a solid foundation for transfer in RL. We derived a theoretical result, Theorem 2, that formalizes the intuition that an agent should perform well on a novel task if it has seen a similar task before. We also illustrated how this effect manifests in practice using experiments.
We believe the ideas presented in this paper lay out a general framework for transfer in RL. By specializing the basic components presented here one can build on our results to derive agents able to perform well across a wide variety of tasks, and thus handle environments of considerable complexity.
Acknowledgments
The authors would like to thank Joseph Modayil and Hado van Hasselt for the invaluable discussions during the development of the ideas described in this paper. We also thank Peter Dayan, Matt Botvinick, Marc Bellemare, and Guy Lever for all the excellent comments. Finally, we thank Dan Horgan and Alexander Pritzel for their help with the experiments.
References
 Argyriou et al. [2008] Andreas Argyriou, Theodoros Evgeniou, and Massimiliano Pontil. Convex multitask feature learning. Machine Learning, 73(3):243–272, 2008.

Asadi and Huber [2007]
Mehran Asadi and Manfred Huber.
Effective control knowledge transfer through learning skill and
representation hierarchies.
In
Proceedings of the International Joint Conference on Artificial Intelligence (IJCAI)
, pages 2054–2059, 2007.  Atkeson and Santamaria [1997] Christopher G. Atkeson and J. Santamaria. A comparison of direct and modelbased reinforcement learning. In Proceedings of the IEEE International Conference on Robotics and Automation, volume 4, pages 3557–3564, 1997.
 Bellman [1957] Richard E. Bellman. Dynamic Programming. Princeton University Press, 1957.
 Bertsekas and Tsitsiklis [1996] Dimitri P. Bertsekas and John N. Tsitsiklis. NeuroDynamic Programming. Athena Scientific, 1996.
 Boyan [2002] Justin A. Boyan. Technical update: Leastsquares temporal difference learning. Machine Learning, 49:233–246, 2002.
 Dayan [1993] Peter Dayan. Improving generalization for temporal difference learning: The successor representation. Neural Computation, 5(4):613–624, 1993.
 Hastie et al. [2002] Trevor Hastie, Robert Tibshirani, and Jerome Friedman. The Elements of Statistical Learning: Data Mining, Inference, and Prediction. Springer, 2002.
 Littman et al. [2001] Michael L. Littman, Richard S. Sutton, and Satinder Singh. Predictive representations of state. In Advances in Neural Information Processing Systems (NIPS), pages 1555–1561, 2001.
 Mahadevan and Maggioni [2007] Sridhar Mahadevan and Mauro Maggioni. Protovalue functions: A Laplacian framework for learning representation and control in Markov decision processes. Journal of Machine Learning Research, 8:2169–2231, 2007.

Mikolov et al. [2013]
Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean.
Efficient estimation of word representations in vector space.
CoRR, 2013.  Mnih et al. [2015] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Humanlevel control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
 Ng and Russell [2000] Andrew Ng and Stuart Russell. Algorithms for inverse reinforcement learning. In Proceedings of the International Conference on Machine Learning (ICML), pages 663–670, 2000.
 Parr et al. [2007] Ronald Parr, Christopher PainterWakefield, Lihong Li, and Michael Littman. Analyzing feature generation for valuefunction approximation. In Proceedings of the International Conference on Machine Learning (ICML), pages 737–744, 2007.

Parr et al. [2008]
Ronald Parr, Lihong Li, Gavin Taylor, Christopher PainterWakefield, and
Michael L. Littman.
An analysis of linear models, linear valuefunction approximation, and feature selection for reinforcement learning.
In Proceedings of the International Conference on Machine Learning (ICML), pages 752–759, 2008.  Petrik [2007] Marek Petrik. An analysis of laplacian methods for value function approximation in MDPs. In Proceedings of the International Joint Conference on Artificial Intelligence (IJCAI), pages 2574–2579, 2007.
 Puterman [1994] Martin L. Puterman. Markov Decision Processes—Discrete Stochastic Dynamic Programming. John Wiley & Sons, Inc., 1994.
 Schaul et al. [2015] Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal Value Function Approximators. In International Conference on Machine Learning (ICML), 2015.
 Strehl and Littman [2005] Alexander L. Strehl and Michael L. Littman. A theoretical analysis of modelbased interval estimation. In Proceedings of the International Conference on Machine Learning (ICML), pages 857–864, 2005.
 Sutton [1996] Richard S. Sutton. Generalization in reinforcement learning: Successful examples using sparse coarse coding. In Advances in Neural Information Processing Systems (NIPS), pages 1038–1044, 1996.
 Sutton and Barto [1998] Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. MIT Press, 1998.
 Sutton et al. [1999] Richard S. Sutton, Doina Precup, and Satinder Singh. Between MDPs and semiMDPs: a framework for temporal abstraction in reinforcement learning. Artificial Intelligence, 112:181–211, August 1999.
 Taylor and Stone [2009] Matthew E. Taylor and Peter Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10(1):1633–1685, 2009.
 Watkins and Dayan [1992] Christopher Watkins and Peter Dayan. Qlearning. Machine Learning, 8:279–292, 1992.
 Yao et al. [2014] Hengshuai Yao, Csaba Szepesvari, Richard S Sutton, Joseph Modayil, and Shalabh Bhatnagar. Universal option models. In Advances in Neural Information Processing Systems (NIPS), pages 990–998, 2014.
Appendix A Proofs
Theorem 1.
(Generalized Policy Improvement) Let , , …, be decision policies and let , , …, be approximations of their respective actionvalue functions such that
Define
Then,
for any and any , where is the actionvalue function of .
Proof.
To simplify the notation, let
We start by noting that for any and any the following holds:
For all , , and we have
Since for any , it must be the case that
Let for all . It is well known that for any . Using this fact together with the monotonicity and contraction properties of the Bellman operator , we have
∎
Lemma 1.
Let . Then,
Proof.
To simplify the notation, let . Then,
(10) 
Our strategy will be to bound and . Note that is the difference between the value functions of two MDPs with the same transition function but potentially different rewards. Let . Then, ^{4}^{4}4We follow the steps of Strehl and Littman [19].
(11) 
Since (A) is valid for any , we have shown that . Solving for we get
(12) 
We now turn our attention to . Following the previous steps, define . Then,
Solving for , as above, we get
(13) 
Plugging (12) and (13) back in (A) we get the desired result. ∎
Theorem 2.
Let and let be the value function of an optimal policy of when executed in . Given the set
Comments
There are no comments yet.