Transfer Learning by Modeling a Distribution over Policies

TL;DR

This paper proposes a Bayesian deep reinforcement learning approach that models a distribution over policies to enhance exploration and transfer learning, demonstrating improved performance on GridWorld and MiniGrid environments.

Contribution

It introduces a novel transfer strategy based on modeling a policy distribution, which promotes diversity and faster exploration in reinforcement learning.

Findings

Faster exploration in transfer learning tasks.

Improved performance on GridWorld and MiniGrid environments.

Supports hypothesis that policy diversity aids transfer learning.

Abstract

Exploration and adaptation to new tasks in a transfer learning setup is a central challenge in reinforcement learning. In this work, we build on the idea of modeling a distribution over policies in a Bayesian deep reinforcement learning setup to propose a transfer strategy. Recent works have shown to induce diversity in the learned policies by maximizing the entropy of a distribution of policies (Bachman et al., 2018; Garnelo et al., 2018) and thus, we postulate that our proposed approach leads to faster exploration resulting in improved transfer learning. We support our hypothesis by demonstrating favorable experimental results on a variety of settings on fully-observable GridWorld and partially observable MiniGrid (Chevalier-Boisvert et al., 2018) environments.

Equations

$$\text{Max}\mathcal{L}(f)={\mathbb{E}}_{f\sim p(f)}[R(D\mid f)+\log \bar{p}(f)]+\lambda H(f)$$

$$H(f)\ge H(z)+{\mathbb{E}}_{f,z\sim p(f,z)}[\log q(z\mid f)]+H(f\mid z)$$

Full text

Transfer Learning, Generative Modeling, Reinforcement Learning, ICML

1 Introduction

Reinforcement learning (RL) has had major success recently, in terms of mastering highly complex games like Go (Silver et al., 2017) and robotic control tasks. However, the ability of agents to transfer across tasks still remains an important problem to be solved towards artificial general intelligence. Transfer learning plays a crucial role in this; to give the agents the ability to adapt across tasks. In this work, we postulate that a key step towards transfer and multi-task learning is for the agent to be able to adapt and explore faster in the new task. Our goal is for the agent to explore unseen regions of the state space quickly in new tasks by re-using its past experiences. However, doing this in the on-policy setting is difficult, since the agent cannot re-use its past data as the task changes. Towards this, we provide an approach for faster exploration in the new task.

We present a transfer learning strategy which fundamentally relies on Bayesian deep learning and the ability to represent a distribution over functions, as in (Bachman et al., 2018) (Garnelo et al., 2018). Bayesian methods rely on modeling the uncertainty over value functions to represent the agent’s belief of the environment. Recent work has shown that neural networks can be used to represent an uncertainty over the space of all possible functions (Bachman et al., 2018). The idea of modeling a distribution over functions can be adapted in the RL setting to model a distribution over policies, such that we can also maximize the entropy over this distribution of policies. This is similar to maximum entropy exploration in RL, where instead of local entropy maximization, recent work maximizes the global entropy over the space of all possible sub-optimal policies.

Our work relies on modeling a distribution over policies for transfer learning, where the pre-trained policies can be useful for learning the target policy in the transfer setup. We hypothesize that if for a given task, we can maximize the entropy of the distribution over policies, then this model can be useful for transfer. This is because, in the new tasks, each sampled policy would lead to a highly diverse trajectory, leading to faster coverage of the state space.

We build upon a recent work named VFunc (Bachman et al., 2018), which presents a framework to represent a distribution over functions rather than the space of parameters. VFunc models the distribution $p(f,z)$, where $f$ is an element of the function space and $z$ is the latent variable. VFunc not only mitigates the intractable modeling of uncertainty in the parameter space but also leads to an efficient method of sampling of functions.

VFunc can be viewed as the maximization of the entropy-regularized objectives of the form: $\mathcal{L}(f)=\mathbb{E}_{f\sim p(f)}\left[R(f)\right]+\lambda\cdot H(f)$. Here, $R(f)$ is a measure of the “goodness” of the function $f$, and $H(f)$ represents the entropy of $f\sim p(f)$. $R(f)$ can be the data log-likelihood in case of Bayesian deep learning or the reward in case of RL. Note that the efficient sampling of functions $f\sim p(f)$, by marginalizing $z$ from $p(f,z)$ in VFunc, can be directly used towards maximization of these objectives. Further, the joint distribution $p(f,z)$ can be utilized to obtain a variational lower bound for the entropy term $H(f)$. Thus, the approach of modeling $p(f,z)$ can be applied in an efficient and simple manner to a large number of Bayesian deep learning and RL problems. In reinforcement learning, the aim is to maximize a reward term $\mathbb{E}_{\pi\sim p(\pi)}\left[R(\pi)\right]$, measuring the goodness of the policy $\pi$, subject to large exploration in the policy space ensured by the term $H(p(\pi))$, which represents the entropy of the distribution over policies. Note that by varying the latent variable $z$, we can obtain different policies.

To summarize, we propose a transfer learning approach based on modeling a distribution over policies. The entropy term in the optimization objective forces the model to consider a diverse set of functions while training. Since the learned policy parameters in the train (source) task are representative of the policy distribution, it improves the exploration of trajectories in the test (target) task. This offers benefits as compared to learning the target policy based on random explorations as the knowledge gained from the source task can be efficiently transferred to the target task to improve performance. Extensive experimentation on GridWorld and MiniGrid demonstrates that transfer to target environments by training with VFunc on the source environment not only results in improved convergence but also leads to diversity in learned policies.

2 Related Work

Significant work has been done investigating various approaches for transfer learning (Taylor & Stone, 2009; Lazaric, 2012). These include meta-learning based transferable strategies (Gupta et al., 2018), learning decision states with information bottleneck for transfer (Goyal et al., 2019), attention-based deep architectures for selective transfer (Rajendran et al., 2015), semi-Markov Decision Processes based approach (Mehta et al., 2008), distillation based approach (Teh et al., 2017), and successor features based transfer (Barreto et al., 2017). In contrast, our approach utilizes diverse exploration in policy space via variational lower bound maximization of entropy-regularized objectives as the basis of transfer. There has also been some work that considers the problem of exploration strategies (Schmidhuber, 1991; Osband et al., 2016; Houthooft et al., 2016). However, these approaches do not carry out transfer of learning from source task to target tasks.

In addition, recent works (Haarnoja et al., 2018b; Neu et al., 2017; Nachum et al., 2017) demonstrate the advantages of entropy-regularized approaches. Also, there has been significant work on modeling policies with latent variables (Hausman et al., 2018; Florensa et al., 2017; Haarnoja et al., 2018a; Eysenbach et al., 2018). In particular, the contribution of (Hausman et al., 2018) is the policy gradient formulation for hierarchical policies with task-conditional latent variables. On the other hand, we rely on optimization of the entropy-regularized objectives for inducing diversity with latent variable based modeling of distribution over policies.

3 Method Description

In this section, we provide a brief description of VFunc (Bachman et al., 2018), a deep generative model for modeling a distribution over the function space. Later, we describe how we use VFunc to do transfer learning.

3.1 Modeling Distribution over Policies

VFunc (Bachman et al., 2018) consists of a prediction network for a stochastic mapping of inputs to outputs and a recognition network for encoding a function into a latent variable. The prediction network $p(y\mid x,z)$ maps the inputs $x$ to outputs $y$ conditioned on latent variable $z$. In the case of RL problems, the underlying function $f$ is the policy, the inputs $x$ are the state representations and the outputs $y$ are the corresponding actions. The space of the latent variable $z$ is assigned a latent variable prior, denoted by $p(z)$. Analogously, the space of the functions (policies) $f$ is assigned a function prior $\bar{p}(f)$. The recognition network $q(z\mid f)$ learns a latent variable encoding for policy $f$. Further, the variational lower bound on the entropy term is formulated using the recognition network. The optimization objective which allows estimation of the true posterior $p(f\mid D)$ given dataset $D$, is given as follows (taken directly from (Bachman et al., 2018)):

[TABLE]

The data-dependent reward term $\mathbb{E}_{f\sim p(f)}[R(D\mid f)]$ can be computed via standard policy-gradient techniques like A2C or REINFORCE. The function prior $\bar{p}(f)$ can be chosen to be unnormalized energy, i.e., arbitrary regularizer function. The estimation of $H(f)$ is not so straight-forward. However, it can be achieved by variational lower bound given below (taken directly from (Bachman et al., 2018)):

[TABLE]

The latent variable prior $p(z)$ is chosen to have simple estimation of $H(z)$. (Bachman et al., 2018) model $p(y\mid x,z)$ to be a Gaussian distribution so that $H(f\mid z)$ estimation becomes easier. Finally, the conditional cross-entropy term can be computed in terms of recognition network $q(z\mid f)$ and the underlying joint distribution $p(f,z)$. Thus, from using the lower bound from Eqn.2, we can compute a lower bound estimate of the optimization objective.

VFunc models a function $f$ as a set of $K$ input-output pairs, called as a partially observed version of the function, denoted by $\hat{f}$. To generate a (partially observed) policy function given a latent variable, they sample $K$ state representations $\{x_{k}\}_{k=1}^{K}$ from the space of inputs and sample actions $y_{k}\sim p(y\mid x_{k},z)$. Thus, the partially observed policy $\hat{f}$ is given by the input-output pairs: $\hat{f}=\{(x_{k},y_{k})\}_{k=1}^{K}$. On the other hand, to encode a partially observed policy $\hat{f}=\{(x_{k},y_{k})\}_{k=1}^{K}$, they use the prediction network and a fixed default latent variable $\bar{z}$ to obtain the default output $\hat{y}_{k}$. Then, the loss function for each input-output pair is computed as $L(y_{k},p(y\mid x_{k},\bar{z}))$. Back-propagating the sum of all such loss functions gives a differential gradient $\sum_{k=1}^{K}\nabla_{\bar{z}}L(y_{k},p(y\mid x_{k},\bar{z}))$, which is an indicative of how skewed the prediction network is when the fixed default latent variable is used for prediction. This gradient forms the input to a multi-layer feed-forward network that essentially forms $q(z\mid\hat{f})$ and predicts a latent variable $z$ for $\hat{f}$.

3.2 Transfer Learning with VFunc

For transfer learning with VFunc, we consider a set of tasks and the train, test task distributions222Here, train and test task distributions refer to source and target task distributions, respectively.: $P_{\mathrm{train}},P_{\mathrm{test}}$. In the training phase, a task $\tau_{\mathrm{train}}$ is sampled from $P_{\mathrm{train}}$. The parametrized policy $\pi_{\theta}$ is trained on the train task $\tau_{\mathrm{train}}$ with the VFunc algorithm (Bachman et al., 2018) (using Eq. 1) to obtain trained parameters $\theta^{\ast}$. Note that the training promotes exploration in the policy space due to the entropy term $H(f)$ in the objective 1. Thus, the learned parameters encode the knowledge of the policy distribution.

For transfer, we sample a new test task $\tau_{\mathrm{test}}$ from $P_{\mathrm{test}}$. For training a policy on the test task, we initialize the policy parameters with $\theta^{\ast}$. Since the pre-trained parameters represent a good and diverse encoding of policy distribution, it improves the exploration of trajectories in the test task. Instead of relying on random exploration of trajectories, which would be the case if VFunc based pre-trained parameters are not incorporated, the learning of policy involves better and faster trajectory exploration owing to the knowledge gained from the train task. Thus, we expect to observe faster learning and faster convergence to the maximum rewards in the test task. The results of the experiments, as described in the subsequent section, indeed validate this hypothesis. Our transfer learning algorithm is described in Algorithm 1 and its schematic representation is depicted in Figure 1.

4 Implementation

In order to test our hypothesis, we carried out multiple experiments on different environments and variable settings within each environment. In these experiments, we compared training with VFunc to training with vanilla policy gradient-approaches. We provide the details of the environments used and various experimental settings below.

4.1 Environments Used

4.1.1 GridWorld

In this class of fully-observable environments, the task is to reach from a start position to a goal position in a rectangular grid. There is a reward of $+1$ on reaching the goal and a small penalty for the number of steps taken to reach the goal. Actions are deterministic and correspond to movement in the four directions. We experimented with six square gridworld domains of size 20 implemented with EasyMDP333Easy MDP: https://github.com/zafarali/emdp. The details of each are provided in Figure 2.

4.1.2 MiniGrid

We also experimented with the partially-observable class of gridworld gym environments called MiniGrid (Chevalier-Boisvert et al., 2018). Specifically, we used the Multi-Room Environment suite with 2 and 3 rooms of sizes 4 and 6. This environment has a series of connected rooms with doors that must be opened in order to get to the next room. The final room has the green goal square the agent must reach in order to get a reward of +1. There is a small penalty added for the number of steps to the reach the goal. There are two settings which we experimented with. In the first setting [Dynamic], a different environment with the same configuration is chosen randomly at the beginning of each episode. The number of rooms and size of each room remains constant, but the positions of rooms, the way they are connected and the position of doors is dynamic. These factors make this suite of environments extremely difficult to solve using RL alone. In the second setting [Static], the environment at the beginning of each episode is kept same by fixing the seed.

4.2 Experiments

4.2.1 Comparison with REINFORCE on GridWorld

We built upon the code base provided for VFunc by (Bachman et al., 2018) and modified it to carry out transfer on different environments. In all experiments we took Grid-1 2(a) as the source environment where training is carried out using both REINFORCE (Williams, 1992) and VFunc and the corresponding weights are stored. We then tested the performance on five different target environments(Grid-2, Grid-3, Grid-6, Grid-7 and Grid-8) with varying levels of difficulty and variation from the source environment. As can be seen from Figure 2, we test on target environments where we add a horizontal wall in Grid-2, more vertical walls in Grid-3 and a combination of both horizontal and vertical walls in Grid-6. Grid-7 and Grid-8 are same as Grid-3 and Grid-6 respectively, but with the position of the goal state changed. We trained the source environment with both REINFORCE and VFunc (See Algorithm 1 and description from Figure 1). This resulted in two sets of weights which were then used to initialize the network weights in the target environment. We then retrained the target environment with both REINFORCE and VFunc. For better comparison, we also trained the target environment from scratch (without initializing the network weights from the source environment) using both REINFORCE and VFunc.

4.2.2 Comparison with A2C on MiniGrid

We implemented Advantage Actor-Critic (called A2C henceforth) by (Mnih et al., 2016) as the policy-gradient algorithm and VFunc on top of it. The source environment was N2S4, i.e., a series of two rooms each of size four which was trained both with A2C and VFunc. We observed the performance while transferring the weights to N2S6 (two rooms of size six) and N3S4 (three rooms of size four) as the target environments and retraining using both A2C and VFunc. As before, we also trained the target environments from scratch without any weights initialized from the weights learned during training on the source environment. We experimented with both the Static and Dynamic settings.

5 Results and Discussions

5.1 Results on GridWorld

The performance was measured by plotting the cumulative reward averaged across episodes and parallel processes with respect to the number of updates. We perform runs with 3 or more random seeds. Figures 4 shows the results for transfer to Grid-2, Grid-3, Grid-6, Grid-7 and Grid-8 after training on Grid-1 as source; as well as training on these target environments from scratch. In the plots, the blue curve corresponds to the case when the weights of the source environment trained on VFunc are used to do transfer on the target environment. The red curve corresponds to the same case except that the weights of the source environment come from REINFORCE. The purple curves correspond to training from scratch on the target environment. Shaded regions around each curve reflect the variability in runs carried out across multiple seeds. In terms of difficulty, Grid-2 should be the most difficult to do transfer learning as it differs the most from the source environment (Grid-1). It is also difficult to learn from scratch as there is only one unblocked path on the far left which leads from the start to goal state. As we can see from Figure 4(a), transferring with VFunc trained weights is able to learn fast. Training from scratch on Grid-2 is the worst. In fact, it is not able to learn anything useful. On Grid-3 and Grid-6, Figures 4(b) and 4(c), VFunc performs the best. Grid-7 is comparatively easy to solve due to its high resemblance to the source environment and VFunc emerges as a clear winner here (Figure 4(d)) as it is able to transfer the knowledge present in the distribution of policies learned in the source environment quite readily to the target environment. Grid-8 being of medium difficulty and the goal state changed makes VFunc not the best choice to do transfer learning. In fact, training from scratch is better here (Figure 4(e)).

In Figure 5, we also show sample heatmaps for the state visitation frequency corresponding to roll-outs pertaining to 16 different samples values of the latent variable, $z$ for Grid-2, Grid-3 and Grid-7. We see that transfer with VFunc pretrained model leads to finding successful paths between the start and goal states in all cases. In some cases, pretraining with REINFORCE or training from scratch on target environment is not able to discover any path between the start and goal states. We also see that the target policies learned by VFunc are quite diverse (as indicated by occasional blueness in the trajectory heatmaps) suggesting its usefulness for exploration in the target environment.

5.2 Results on MiniGrid

Figures 7(a) and 7(b) shows the results of transfer experiments carried out on N2S6 and N3S4 using N2S4 as the source environment in the Dynamic setting. Figures 7(c) and 7(d) represent the same for Static setting. The description of the legends is the same as above. All experiments correspond to runs with 5 different random seeds. As can be seen from the plots, training on N2S4 with VFunc and transferring using VFunc converges in less number of updates for both the settings and for both environments: N2S6 and N3S4. When we retrain with A2C on the target environment, the performance of VFunc is at par with A2C trained weights on N2S4. Training from scratch in the target environments is useless here. We believe that better hyperparameter tuning will help VFunc outperform A2C pretraining for N3S4. Besides, transfer to more complex environments will showcase the benefits of VFunc in a more appealing way.

6 Conclusions and Future Work

We observe that learning the target policy when pre-training with VFunc leads to faster convergence as compared to pre-training with other policy-gradient techniques (like REINFORCE and A2C) in the source task as well as training from scratch on the target task. The difference is more apparent as the difficulty level of the environment increases in terms of its variation from the source environment and environment dynamics (partial observability, degree of stochasticity, etc.). The explanation for improved transfer performance of VFunc is that during training with VFunc on the source environment, the model learns a distribution of good policies to explore in the target environment. This leads to faster exploration and hence, faster convergence. In addition, the learned policies are more diverse. In future, we wish to explore the Safe AI perspective (Jain et al., 2018) wherein the idea is that since VFunc learns a distribution over policies rather than a single optimal policy, it will be able to learn few policies which avoid dangerous states (states with a very high penalty). We plan to experiment with AI Safe GridWorlds in (Leike et al., 2017) for this task.