Dyna-AIL : Adversarial Imitation Learning by Planning

TL;DR

Dyna-AIL introduces a novel adversarial imitation learning approach that combines model-based planning and model-free learning, significantly reducing environment interactions needed for convergence in control tasks.

Contribution

It proposes an end-to-end differentiable adversarial imitation learning algorithm within a Dyna-like framework, effectively switching between planning and learning from expert data.

Findings

Converges to optimal policy with fewer environment interactions.

Effective on both discrete and continuous environments.

Outperforms state-of-the-art methods in sample efficiency.

Abstract

Adversarial methods for imitation learning have been shown to perform well on various control tasks. However, they require a large number of environment interactions for convergence. In this paper, we propose an end-to-end differentiable adversarial imitation learning algorithm in a Dyna-like framework for switching between model-based planning and model-free learning from expert data. Our results on both discrete and continuous environments show that our approach of using model-based planning along with model-free learning converges to an optimal policy with fewer number of environment interactions in comparison to the state-of-the-art learning methods.

Equations

$${\mathrm{argmin}}_{\pi }{\mathrm{argmax}}_{D\in (0,1)}{\mathbb{E}}_{\pi }[\log (D(s,a))]+{\mathbb{E}}_{{\pi }_E}[\log (1-D(s,a))]$$

$$J_{s}=\mathbb{E}_{p(a|s)}\mathbb{E}_{p(s^{\prime}|s,a)}\Bigg{[}D_{s}+D_{a}\pi_{s}+\gamma J^{\prime}_{s^{\prime}}(f_{s}+f_{a}\pi_{s})\Bigg{]},$$

$$J_{\theta}=\mathbb{E}_{p(a|s)}\mathbb{E}_{p(s^{\prime}|s,a)}\Bigg{[}D_{a}\pi_{\theta}+\gamma(J^{\prime}_{s^{\prime}}f_{a}\pi_{\theta}+J^{\prime}_{\theta})\Bigg{]}.$$

$${\mathbb{E}}_{\pi }[\log (D(s,a))]+{\mathbb{E}}_{{\pi }_E}[\log (1-D(s,a))].$$

$$L_f=\sum _{(s,a,s^{\prime })\in B}\frac{1}{2}||f(s,a)-(s^{\prime }-s)|{|}^2$$

$${\hat{\mathbb{E}}}_{{\tau }_i}[{\nabla }_{{\theta }_d}\log (D_{{\theta }_d}(s,a))]+{\hat{\mathbb{E}}}_{{\tau }_E}[{\nabla }_{{\theta }_d}\log (1-D_{{\theta }_d}(s,a))]$$

$$\nabla_{\theta_{g}}\mathbb{E}_{\tau_{i}}\bigg{[}\sum_{t=0}\gamma^{t}\log(D(s_{t},a_{t}))\bigg{]}$$

$$\nabla_{\theta_{g}}\mathbb{E}_{\tau_{j}}\bigg{[}\sum_{t=0}\gamma^{t}\log(D(s_{t},a_{t}))\bigg{]}$$

Full text

1 Introduction

Reinforcement learning (RL) refers to the learning framework where an agent tries to learn the optimal policy by obtaining rewards from the environment through interaction. However, learning a policy from scratch is often difficult and involves numerous agent interactions with the environment. Further, in many cases, it is difficult to obtain explicit reward for actions taken from the environment. Imitation learning solves this problem by learning a policy from expert’s state-action-state trajectories without access to reinforcement signal from the environment or interaction with the expert. Imitation is essential in applications including automation (e.g., imitating a human expert), distillation (e.g., if the expert is too expensive to run in real time [1]), and initialization (e.g., using an expert policy as an initial solution).

Reinforcement learning methods can be broadly classified into Model-Based (MB) methods involving planning with a world model and Model-Free (MF) methods involving learning by reactive execution in the environment. While MF methods can be used to learn complex policies in high-dimensional state spaces, they incur a huge cost in the number of interactions required with the environment. Use of a model reduces the number of such interaction trials drastically, but requires the dynamics model to be very accurate as a small bias in the model can lead to a strong bias in the policy.

Dyna [2] based methods use a combined approach wherein the policy is learned by alternating between MB and MF methods. Using MB prior for MF RL (MBMF) is another kind of method that incorporates advantages of both MB and MF paradigms, by learning a probabilistic dynamics model which later acts as a prior for model-free optimization [3].

Ho and Ermon et al. (2016) proposed Generative Adversarial Imitation Learning (GAIL) [4], an algorithm for performing imitation learning in a model-free setup using a GAN-like architecture, where the generator acts as the policy and the discriminator function judges whether an action given to it is from an expert or from the imitating policy. In this method, the agent learns the expert behaviour by an on-policy update on the state transition observations from the environment. However, in many practical learning situations, interactions with the environment are quite expensive. In this paper, we propose Dyna Adversarial Imitation Learning (Dyna-AIL), a framework for adversarial imitation learning by learning the expert policy by switching between world-model based planning and model-free reactive execution.

The remaining of this paper is organized as follows: in Section 2, we talk about the existing adversarial imitation learning algorithms, and in Section 3, we introduce our proposed Dyna-AIL algorithm. Section 4 gives the experiments that we performed to test our algorithm, and finally, in Section 5, we discuss the results obtained from our experiments alongside the strengths and limitations of our algorithm.

2 Background

2.1 Generative Adversarial Imitation Learning

Ho and Ermon (2016) proposed the Generative Adversarial Imitation Learning (GAIL) [4] architecture for learning policies from expert data using Generative Adversarial Networks [5]. GAIL is a model-free approach wherein, the adversarial two-player zero-sum game can be represented as follows:

[TABLE]

A discriminator function $D$ tries to maximize the objective in (1), while a policy function $\pi$ tries to minimize it. In a neural network implementation, GAIL alternates between an Adam gradient [6] step on the parameters of $D$, and a Trust Region Policy Optimization (TRPO) [7] gradient step on the parameters of $\pi$ which minimizes the cost $c(s,a)=\log D(s,a)$ for the policy. Fig. 1 shows how the gradients are passed from the discriminator down to the policy network. Since the state transitions are taken from the environment, the gradient w.r.t. state $s$ ($\delta_{s}$) does not pass through to the policy, or in other words, it is ignored and not used for the policy update.

2.2 End-to-end differentiable Adversarial Imitation Learning (MGAIL)

Baram et al. (2017) [8] proposed an end-to-end differentiable version of GAIL where they use a forward-model through which the gradient of discriminator $D$ w.r.t. the state $s$ can be used for the policy update. They argue that since REINFORCE policy gradients suffer from high variance, it is difficult to work with them even after using variance reduction techniques. They also state that REINFORCE gradients are not same as the exact gradient of $D$, due to the independence assumption of state transitions w.r.t. policy parameters taken in REINFORCE. So, if we assume that the state transition probabilities are dependent on the policy parameters, i.e. use exact gradients through the incorporation of a forward-model, the policy will receive better signals while learning. They build an end-to-end differentiable computation graph that spans over multiple time-steps as given by Heess et al. (2015) [9] in their formulation, which for a transition ($s,a,s^{\prime}$) is given as:

[TABLE]

[TABLE]

The gradient with respect to an entire trajectory is obtained by applying (2) and (3) recursively over the trajectory, and is illustrated in Fig. 2. We note that MGAIL still uses state transitions from the environment while unrolling trajectories, probably because of an inadequacy in the forward-model capacity which would otherwise lead to noisy state transitions, and use a re-parameterization of environment state transitions so as to calculate gradients.

2.3 Comparing the Adversarial Imitation Learning algorithms

Baram et al. (2017) added a forward-model in their algorithm so as to pass the gradient of discriminator $D$ w.r.t. state $s$ down to the policy network. However, they still sampled trajectories from the environment for computing the loss for the policy as well as the discriminator. In order to compute the gradients of the discriminator w.r.t. states, they re-parameterize the observed state $s^{obs}_{t+1}$ as $s^{pred}_{t+1}+\nu$, where $\nu=s^{obs}_{t+1}-s^{pred}_{t+1}$ as shown in Fig. 2. Hence, MGAIL, like GAIL, is a model-free algorithm w.r.t. the state transitions.

3 Algorithm

The Dyna architecture proposed in [2] integrates both model-based planning and model-free reactive execution to learn a policy. In this work, we present an algorithm (Algorithm 1) for using the Dyna architecture with adversarial imitation learning methods to obtain improvement over environment sampling efficiency. Our aim is to learn a discriminator function $D$ and a policy function $\pi$ which respectively maximize and minimize the expression

[TABLE]

We use a neural network function approximator for $D$ and $\pi$, and use a set of expert trajectories to calculate the expectation w.r.t. $\pi_{E}$. Now, in every iteration, we alternate between a learning phase and a planning phase. During the learning phase, we sample trajectories using $\pi$ on the environment to make transitions, and take a gradient step on $D$ using (6) in order to maximize (4). Then we use an on-policy gradient update on $\pi$ using (7) so as to minimize (4). In every iteration, we train the forward-model by minimizing the squared loss

[TABLE]

between the state transition predictions from the forward-model and the observed state transitions $(s,a,s^{\prime})$ sampled from trajectories stored in the experience replay buffer $B$. To better represent the environment by a neural network function approximator, we designed the output of our forward-model as the change in the state values $f(s,a)=\delta{s_{pred}}$ such that $s_{pred}^{\prime}=s+f(s,a)$.

During the planning phase, we sample trajectories using $\pi$ on the forward-model for state transitions, and take a gradient step on $\pi$ using (8). By having a planning step in every iteration, our approach optimizes the number of environment interactions required to imitate an expert policy, as shown in the experiments.

In our experiments, we use the multi-step computation graph with gradient updates as given in (2) and (3). However, we also discuss our algorithm’s performance using natural policy gradient update with TRPO rule, in Section 5, for comparison with [4].

4 Experiments and Results

We evaluate our proposed algorithm on one discrete control task (CartPole [10]), and two continuous control tasks (Hopper, HalfCheetah) modeled by the MuJoCo [11] physics simulator, using the cost function defined in the OpenAI Gym [12]. We use the Trust Region Policy Optimization (TRPO) [7] algorithm to train our expert policies. For each of the tasks, we generated expert datasets with a number of trajectories ($n_{T}=50$), where each trajectory: $\tau={s_{0},a_{0},s_{1},...s_{N},a_{N}}$ is of length N = 1000.

The discriminator and policy networks are each designed with two hidden layers (200 and 100 units for discriminator, and 100 and 50 units for policy) with ReLU non-linearity and trained using the Adam [6] optimizer (similar to the architectures used in [8]). As noted in [8], the forward-model structure is crucial for the stability of the network’s learning process. Since the state and action inputs are from different distributions, we embed them into a shared space using state and action encoder networks. Then, we combine the embeddings through a Hadamard product and use that as input for the state transition model. We also model the environment as a nth order MDP, with a recurrent connection from the previous states, using a GRU layer as a part of the state encoder (as previously used in [8]).

In every iteration of Algorithm 1, we perform the updates in (6) and (7) using a $m$-step ($m=50$) stochastic gradient descent with trajectories sampled from the environment. Later in the iteration, we perform planning in (8) using a $p$-step ($p=50$) stochastic gradient descent with trajectories sampled from the forward-model. To ensure the stability of the planner, we restrict the unrolling of the trajectory in planning phase to a fixed number of steps ($T_{p}$). In Section 5, we discuss the performance of our algorithm by varying the trajectory lengths $T_{p}$.

After every iteration, the policy learned in the algorithm was evaluated using 10 episodes by acting on the environment. Fig. 4 shows the learning curve comparison between our algorithm and MGAIL. From the experimental results, we observe that our algorithm learns the optimal policy with fewer number of interactions with the environment, as compared to MGAIL. However, in the case of Hopper environment, our algorithm has a high variance in performance, which could be attributed to the bias introduced by the forward-model used for sampling trajectories in the planning phase. In Section 5, we discuss a few possible solutions for overcoming the instability issues.

5 Discussion

To evaluate the stability of our Dyna planner w.r.t the planning phase trajectory length $T_{p}$, we performed experiments with different values of $T_{p}$ on Hopper and HalfCheetah environments. Fig. 5 shows the learning curves for $T_{p}=5,10,50$. We observe that with the Hopper environment, the learning curve has a higher variance with $T_{p}=50$ as compared to with lower values of $T_{p}$. However, with the HalfCheetah environment, learning curves for all $T_{p}$ values converge with very low variance. We attribute this behavior to the capacity of the forward-model, which learns a good approximation for the HalfCheetah environment, but is unable to learn the same for the more complex Hopper environment which has a larger state-space. We intend to resolve this issue in future work by engineering the capacity of the forward-model and training it efficiently.

Even though MGAIL addresses the problem of high variance gradients by utilizing the forward-model gradients, they still use a small step size due to the gradient update as per [9]. GAIL copes with the high variance in gradients by performing the policy update using a natural policy gradient step with TRPO update rule. The KL divergence constraint enables us to use a large step size for policy update without worrying about the noisy policy gradients. Hence, we evaluated Dyna-AIL on Hopper environment without forward-model gradients using the TRPO update rule, as per [4]. Fig. 6 shows the performance of the Dyna-AIL algorithm with TRPO update compared with the results of GAIL. The TRPO update ensures that the policy updates do not diverge by adjusting the step size in every gradient update and hence reduces the variance in the Hopper environment. Further, in our future work, we intend to implement an end-to-end differentiable multiple-step computation graph with a natural policy gradient update as per the TRPO rule.

In this paper, we proposed a framework to train policies via imitation learning by switching between model-based planning and model-free execution. The results show that this framework reduces the number of environment interactions required to learn a good policy while imitating an expert. However, we still perform only one planning step for every learning step as there is no direct metric to evaluate the quality of the planning step to stop planning and learn from the environment. Yuexin et. al. (2018) [13], propose an adaptive Dyna-Q framework by integrating a switcher that automatically determines whether to use a real or simulated experience for Q-learning based on a quality metric. A possible future direction is to have an adaptive switching mechanism in our algorithm that could query the environment only when the model is uncertain about a state transition.