user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Making Efficient Use of Demonstrations to Solve Hard Exploration Problems

Paper content:
This paper introduces R2D3, an agent that makes efficient use of demonstrations to solve hard exploration problems in partially observable environments with highly variable initial conditions.
We also introduce a suite of eight tasks that combine these three properties, and show that R2D3 can solve several of the tasks where other state of the art methods (both with and without demonstrations) fail to see even a single successful trajectory after tens of billions of steps of exploration.
Reinforcement learning from demonstrations has proven to be an effective strategy for attacking problems that require sample efficiency and involve hard exploration.
For example, , Pohlen et al. (2018) and Salimans and Chen (2018b) have shown that RL with demonstrations can address the hard exploration problem in Montezuma's Revenge.
Večerík et al. (2017) , Merel et al. (2017) and have demonstrated similar results in robotics.
Many other works have shown that demonstrations can accelerate learning and address hard-exploration tasks (e.g. see Hester et al., 2018; Kim et al., 2013; Nair et al., 2018) .
In this paper, we attack the problem of learning from demonstrations in hard exploration tasks in partially observable environments with highly variable initial conditions.
These three aspects together conspire to make learning challenging:
1. Sparse rewards induce a difficult exploration problem, which is a challenge for many state of the art RL methods.
An environment has sparse reward when a non-zero reward is only seen after taking a long sequence of correct actions.
Our approach is able to solve tasks where standard methods run for billions of steps without seeing a single non-zero reward.
2. Partial observability forces the use of memory, and also reduces the generality of information provided by a single demonstration, since trajectories cannot be broken into isolated transitions using the Markov property.
An environment has partial observability if the agent can only observe a part of the environment at each timestep.
3. Highly variable initial conditions (i.e. changes in the starting configuration of the environment in each episode) are a big challenge for learning from demonstrations, because the demonstrations can not account for all possible configurations.
When the initial conditions are fixed it is possible to be extremely efficient through tracking Peng et al., 2018) ; however, with a large variety of initial conditions the agent is forced to generalize over environment configurations.
Generalizing between different initial conditions is known to be difficult (Ghosh et al., 2017; Langlois et al., 2019) .
Our approach to these problems combines demonstrations with off-policy, recurrent Q-learning in a way that allows us to make very efficient use of the available data.
In particular, we vastly outperform behavioral cloning using the same set of demonstrations in all of our experiments.
Another desirable property of our approach is that our agents are able to learn to outperform the demonstrators, and in some cases even to discover strategies that the demonstrators were not aware of.
In one of our tasks the agent is able to discover and exploit a bug in the environment in spite of all the demonstrators completing the task in the intended way.
Learning from a small number of demonstrations under highly variable initial conditions is not straight-forward.
We identify a key parameter of our algorithm, the demo-ratio, which controls the proportion of expert demonstrations vs agent experience in each training batch.
This hyper-parameter has a dramatic effect on the performance of the algorithm.
Surprisingly, we find that the optimal demo ratio is very small (but non-zero) across a wide variety of tasks.
The mechanism our agents use to efficiently extract information from expert demonstrations is to use them in a way that guides (or biases) the agent's own autonomous exploration of the environment.
Although this mechanism is not obvious from the algorithm construction, our behavioral analysis confirms the presence of this guided exploration effect.
To demonstrate the effectiveness of our approach we introduce a suite of tasks (which we call the Hard-Eight suite) that exhibit our three targeted properties.
The tasks are set in a procedurally-generated 3D world, and require complex behavior (e.g. tool use, long-horizon memory) from the agent to succeed.
The tasks are designed to be difficult challenges in our targeted setting, and several state of the art methods (themselves ablations of our approach) fail to solve them.
The main contributions of this paper are, firstly we design a new agent that makes efficient use of demonstrations to solve sparse reward tasks in partially observed environments with highly variable initial conditions.
Secondly, we provide an analysis of the mechanism our agents use to exploit information from the demonstrations.
Lastly, we introduce a suite of eight tasks that support this line of research.
Figure 1 : The R2D3 distributed system diagram.
The learner samples batches that are a mixture of demonstrations and the experiences the agent generates by interacting with the environment over the course of training.
The ratio between demos and agent experiences is a key hyper-parameter which must be carefully tuned to achieve good performance.
We propose a new agent, which we refer to as Recurrent Replay Distributed DQN from Demonstrations (R2D3).
R2D3 is designed to make efficient use of demonstrations to solve sparse reward tasks in partially observed environments with highly variable initial conditions.
This section gives an overview of the agent, and detailed pseudocode can be found in Appendix A.
The architecture of the R2D3 agent is shown in Figure 1 .
There are several actor processes, each running independent copies of the behavior against an instance of the environment.
Each actor streams its experience to a shared agent replay buffer, where experience from all actors is aggregated and globally prioritized ) using a mixture of max and mean of the TD-errors with priority exponent η = 1.0 as in Kapturowski et al. (2018) .
The actors periodically request the latest network weights from the learner process in order to update their behavior.
In addition to the agent replay, we maintain a second demo replay buffer, which is populated with expert demonstrations of the task to be solved.
Expert trajectories are also prioritized using the scheme of Kapturowski et al. (2018) .
Maintaining separate replay buffers for agent experience and expert demonstrations allows us to prioritize the sampling of agent and expert data separately.
The learner process samples batches of data from both the agent and demo replay buffers simultaneously.
A hyperparameter ρ, the demo ratio, controls the proportion of data coming from expert demonstrations versus from the agent's own experience.
The demo ratio is implemented at a batch level by randomly choosing whether to sample from the expert replay buffer independently for each element with probability ρ.
Using a stochastic demo ratio in this way allows us to target demo ratios that are smaller than the batch size, which we found to be very important for good performance.
The objective optimized by the learner uses of n-step, double Q-learning (with n = 5) and a dueling architecture (Wang et al., 2016; .
In addition to performing network updates, the learner is also responsible for pushing updated priorities back to the replay buffers.
In each replay buffer, we store fixed-length (m = 80) sequences of (s,a,r) tuples where adjacent sequences overlap by 40 time-steps.
The sequences never cross episode boundaries.
Given a single batch of trajectories we unroll both online and target networks (Mnih et al., 2015) on the same sequence of states to generate value estimates with the recurrent state initialized to zero.
Proper initialization of the recurrent state would require always replaying episodes from the beginning, which would add significant complexity to our implementation.
As an approximation of this we treat the first 40 steps of each sequence as a burn-in phase, and apply the training objective to the final 40 steps only.
An Hard-Eight task suite.
In each task an agent ( ) must interact with objects in its environment in order to gain access to a large apple ( ) that provides reward.
The 3D environment is also procedurally generated so that every episode the state of the world including object shapes, colors, and positions is different.
From the point of view of the agent the environment is partially observed.
Because it may take hundreds of low-level actions to collect an apple the reward is sparse which makes exploration difficult.
alternative approximation would be to store stale recurrent states in replay, but we did not find this to improve performance over zero initialization with burn-in.
In this paper, we introduced the R2D3 agent, which is designed to make efficient use of demonstrations to learn in partially observable environments with sparse rewards and highly variable initial conditions.
We showed through several experiments on eight very difficult tasks that our approach is able to outperform multiple state of the art baselines, two of which are themselves ablations of R2D3.
We also identified a key parameter of our algorithm, the demo ratio, and showed that careful tuning of this parameter is critical to good performance.
Interestingly we found that the optimal demo ratio is surprisingly small but non-zero, which suggests that there may be a risk of overfitting to the demonstrations at the cost of generalization.
For future work, we could investigate how this optimal demo ratio changes with the total number of demonstrations and, more generally, the distribution of expert trajectories relative to the task variability.
We introduced the Hard-Eight suite of tasks and used them in all of our experiments.
These tasks are specifically designed to be partially observable tasks with sparse rewards and highly variable initial conditions, making them an ideal testbed for showcasing the strengths of R2D3 in contrast to existing methods in the literature.
Our behavioral analysis showed that the mechanism R2D3 uses to efficiently extract information from expert demonstrations is to use them in a way that guides (or biases) the agent's own autonomous exploration of the environment.
An in-depth analysis of agent behavior on the Hard-Eight task suite is a promising direction for understanding how different RL algorithms make selective use of information.
A R2D3
Below we include pseudocode for the full R2D3 agent.
The agent consists first of a single learner process which samples from both demonstration and agent buffers in order to update its policy parameters.

assistant: text: We introduce R2D3, an agent that makes efficient use of demonstrations to solve hard exploration problems in partially observable environments with highly variable initial conditions.