R ETRIEVAL -A UGMENTED R EINFORCEMENT L EARNING
Anonymous authors
Paper under double-blind review
A BSTRACT
Most deep reinforcement learning (RL) algorithms distill experience into parametric behavior policies or value functions via gradient updates.
While effective, this approach has several disadvantages: (1) it is computationally expensive, (2) it can take many updates to integrate experiences into the parametric model, (3) experiences that are not fully integrated do not appropriately inﬂuence the agent’s behavior, and (4) behavior is limited by the capacity of the model.
In this paper we explore an alternative paradigm in which we train a network to map a dataset of past experiences to optimal behavior.
Speciﬁcally, we augment an RL agent with a retrieval process (parameterized as a neural network) that has direct access to a dataset of experiences.
This dataset can come from the agent’s past experiences, expert demonstrations, or any other relevant source.
The retrieval process is trained to retrieve information from the dataset that may be useful in the current context, to help the agent achieve its goal faster and more efﬁciently.
We integrate our method into two different RL agents: an ofﬂine DQN agent and an online R2D2 agent.
In ofﬂine multi-task problems, we show that the retrieval-augmented DQN agent avoids task interference and learns faster than the baseline DQN agent.
On Atari, we show that retrieval-augmented R2D2 learns signiﬁcantly faster than the baseline
R2D2 agent and achieves higher scores.
We run extensive ablations to measure the contributions of the components of our proposed method.
I NTRODUCTION
A host is preparing a holiday meal for friends.
They remember that the last time they went to the grocery store during the holiday season, all of the fresh produce was sold out.
Thinking back to this past experience, they decide to go early!
The hypothetical host is employing case-based reasoning (e.g., Kolodner, 1992; Leake, 1996).
Here, an agent recalls a situation similar to the current one and uses information from the previous experience to solve the current task.
This may involve adapting old solutions to meet new demands, or using previous experiences to make sense of new situations.
In contrast, a dominant paradigm in modern reinforcement learning (RL) is to learn general purpose behaviour rules from the agent’s past experience.
These rules are typically represented in the weights of a parametric policy or value function network model.
Most deep RL algorithms integrate information across trajectories by iteratively updating network parameters using gradients that are computed along individual trajectories (collected online or stored in an experience replay dataset,
Lin, 1992).
For example, many off-policy algorithms reuse past experience by “replaying” trajectory snippets in order to compute weight updates for a value function represented by a deep network (Ernst et al., 2005; Riedmiller, 2005; Mnih et al., 2015b; Heess et al., 2015; Lillicrap et al., 2015).
This paradigm has clear advantages but at least two interrelated limitations: First, after learning, an agent’s past experiences no longer plays a direct role in the agent’s behavior, even if it is relevant to the current situation.
This occurs because detailed information in the agent’s past experience is lost due to practical constraints on network capacity.
Second, since the information provided by individual trajectories ﬁrst needs to be distilled into a general purpose parametric rule, an agent may not be able to exploit the speciﬁc guidance that a handful of individual past experiences could provide, nor rapidly incorporate novel experience that becomes available—it may take many replays through related traces in the past experiences for this to occur (Weisz et al., 2021).
In this work we develop an algorithm that overcomes these limitations by augmenting a standard reinforcement learning agent with a retrieval process (parameterized via a neural network).
The purpose of the retrieval process is to help the agent achieve its objective by providing relevant contextual information.
To this end, the retrieval process uses a learned attention mechanism to dynamically access a large pool of past trajectories stored in a dataset (e g., a replay buffer), with the aim of integrating information across these.
The proposed algorithm (R2A), shown in Figure 1, enables an agent to retrieve information from a dataset of trajectories.
The high-level idea is to have two different processes.
First, the retrieval process , makes a “query” to search for relevant contextual information in the dataset.
Second, the agent process performs inference and learning based on the information provided by the retrieval process.
These two processes have different internal states but interact to shape the representations and predictions of each other: the agent process provides the relevant context, and the retrieval process uses the context and its own internal state to generate a query and retrieve relevant information, which is in turn used by the agent process to shape the representation of its policy and value function (see Fig.
1A).
Our proposed retrieval-augmented RL paradigm could take several forms.
Here, we focus on a particular instantiation to assay and validate our hypothesis that learning a retrieval process can help an RL agent achieve its objectives.
Summary of experimental results.
We want RL algorithms that are able to adapt to the available data source and usefully ingest any dataset.
Hence, we test the performance of the proposed method in three different scenarios.
First, we evaluate it on Atari games in a single task setting.
We build upon
R2D2 (Kapturowski et al., 2018), a state-of-the-art off-policy RL algorithm.
Second, we evaluate it on a multi-task ofﬂine RL environment, using DQN (Mnih et al., 2013) as the RL algorithm, where the data in the queried dataset belongs to the same task.
Third, we evaluate it on a multi-task ofﬂine
RL environment where the data in the dataset comes from multiple tasks.
In all these cases, we show that R2A learns faster and achieves higher reward compared to the baseline.
R ETRIEVAL -A UGMENTED A GENTS
We now present our method for augmenting an RL agent with a retrieval process, thereby reducing the agent’s dependence on its model capacity, and enabling fast and ﬂexible use of past experiences.
A retrieval-augmented agent (R2A) consists of two main components: (1) the retrieval process, which takes in the current state of the agent, combines this with its own internal state, and retrieves relevant information from an external dataset of experiences; and (2) a standard reward-maximizing
RL agent, which uses the retrieved information to improve its value or policy estimates.
See Figurefor an overview.
The retrieval process is trained to retrieve information that the agent can use to improve its performance, without explicit knowledge of the agent’s policy.
Importantly, the retrieval process has its own internal state, which enables it to integrate and combine information across retrievals.
In the following, we focus on value-based methods, such as DQN (Mnih et al., 2015a) and
R2D2 (Kapturowski et al., 2018), but our approach is equally applicable to policy-based methods.
2. R ETRIEVAL - AUGMENTED AGENT
Formally, the agent receives an input x t at each timestep t .
Each input is processed by a neural encoder (e.g., a resnet if the input is an image) to obtain an abstract internal state for the agent s t =
f enc θ ( x t ) .
For clarity, we focus here on the case of a single vector input, however, each input could also include the history of past observations, actions, and rewards, as is the case when f enc θ is a recurrent network.
These embeddings are used by the agent and retrieval processes.
The retrieval process operates on a dataset B = { ( x t , a t , r t ) , . .
, ( x t + T , a t + T , r t + T ) } of l -step trajectories, for l ≥ 1 .
This dataset could come from other agents or experts, as in ofﬂine RL or imitation learning, or consist of the growing set of the agent’s own experiences.
Then, a retrieval-augmented agent (R2A) consists of the retrieval process and the agent process, parameterized by θ = { θ enc , θ retr , θ agent } ,
[Equation]
Retrieval Process.
The retrieval process is parameterized as a neural network and has an internal state m t .
The retrieval process takes in the current abstract state of the agent process s t and its own previous internal state m t − 1 and uses these to retrieve relevant information from the dataset B , which it then summarizes in a vector u t , and also updates its internal state m t .
Agent Process.
The current state of the agent s t and the information from the retrieval process u t is then passed to the action-value function, itself used to select external actions.
The above deﬁnes a parameterization for a retrieval-augmented agent.
For retrieval to be effective, the retrieval process needs to: (1) be able to efﬁciently query a large dataset of trajectories, (2) learn and employ a similarity function to ﬁnd relevant trajectories, and (3) encode and summarize the trajectories in a manner that allows efﬁcient discovery of relevant past and future information.
Below, we explain how we achieve these desiderata.
At a high-level, to reduce computational complexity given a experience dataset of hundreds of thousands of trajectories, R2A operates on samples from the dataset.
R2A then encodes and summarizes the trajectories in these samples using auxiliary losses and bi-directional sequence models to enable efﬁcient retrieval of temporal information.
Finally, R2A uses attention to select semantically relevant trajectories.
2. R ETRIEVAL BATCH SAMPLING AND PRE - PROCESSING .
Sampling a retrieval batch from the retrieval dataset.
To reduce the computational complexity,
R2A uniformly samples a large batch of past experiences from the retrieval dataset, and only uses the sampled batch for retrieving information.
We denote the sampled batch as “retrieval batch” and the number of trajectories in the retrieval batch as n retrieval .
Encoding and forward-backward summarization of the retrieval dataset and corresponding auxiliary losses.
Since the agent’s internal state extracts information from observations which relate to the task at hand, we choose to re-encode the raw experiences in the ”retrieval batch” using the agent encoder module (i.e., f enc θ ).
However, this representation is a function only of past observations (i.e., it’s a causal representation) and may not be fully compatible with the needs of the retrieval operation.
For that reason, we propose to further encode the retrieved batch of information, by additionally learning a summarization function, applied on the output of the encoder module, and which captures information about the past and the future within a particular trajectory by using a bi-directional model (e.g., parameterized as a bi-directional RNN or a Transformer).
Forward Summarizer f fwd θ : ( s 1 , . . .
, s t ) (cid:55)→ h t
Backward Summarizer f bwd θ : ( s T , . . .
, s t ) (cid:55)→ b t
For each trajectory in the retrieval batch, we represent each time-step within a trajectory by a set of two vectors
h i,t and b i,t (Figure 6 in the appendix) where h i,t summarizes the past (i.e., from
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
Given
[Table]
[Table]
[Table]
kt
[Table]
[Equation]
[Table]
[Equation] [Table]
[Equation]
[Table]
c
[Equation]
β
[Equation]
[Equation] =
[Table]
[Equation] [Table]
where
[Table]
s
[Table]
+ u
[Table]
t (cid:48)
=
to t (cid:48)
=
t time-steps of the i th trajectory) while b i,t summarizes the future (i.e., from t (cid:48)
=
t to t (cid:48)
= (cid:96) time-steps) within the i th trajectory.
In addition, taking inspiration from (Jaderberg et al., 2016; Trinh et al., 2018; Ke et al., 2019; Devlin et al., 2018; Mazoure et al., 2020; Banino et al., 2021), we use auxiliary losses to improve modeling of long term dependencies when training the parameters of our forward and backward summarizers.
The goal of these losses is to force the representation ( h i,t , b i,t ) i,t ≥ 0 to capture meaningful information for the unknown downstream task.
For our experiments, we use supervised losses where we have access to actions or rewards in the retrieval batch.
For ablations we also experiment with self-supervised losses.
For supervised auxiliary losses, we use policy, value and reward prediction (Silver et al., 2017; Schrittwieser et al., 2019), and for self-supervised losses, we use a BERT-style masking loss (Devlin et al., 2018).
2. R ETRIEVING CONTEXTUAL INFORMATION FROM PAST EXPERIENCES .
In this section, we explain how the retrieval process, when provided with relevant contextual information represented by the agent’s current state s t , interacts with the summarized information in the retrieval batch to select information u t to provide to the agent in return.
Retrieval process state parameterization.
We parameterize the process that retrieves information from past experience as a structured parametric model with multiple separate memory slots (or sub-units).
The state of the retrieval process is a set of n f memory slots denoted by m t = { m kt | k ∈ { 1 , . . . , n f }} (indexed by the agent time-step t ).
Slots are initialized randomly at the beginning of the episode.
Each slot independently queries and retrieves relevant information from the pool of data.
Subsequently the slots update their values independently based on the retrieved information.
This is followed by an integration step during which information is shared between slots.
Algorithmprovides a speciﬁcation of the six steps of R2A which we now explain in detail below.
Step 1: Query computation.
Each slot independently computes its prestate using an GRU on the contextual information from the agent: (cid:99) m
[Equation]
∀ k ∈ { 1 , . . . , n f } .
Then, each slot independently computes a retrieval query which will be matched against information in the retrieval batch: q kt = f query ( (cid:99) m kt − 1 ) | k ∈ { 1 , . . . , n f }} 1 where q kt is the query generated by the k th slot at timestep t .
Step 2: Identiﬁcation of most relevant trajectories and states for each slot (Figure 5A).
The retrieval mechanism process uses an attention mechanism to match a query produced by the retrieval state associated with each slot m kt to keys computed on each time step of each trajectory of the retrieval batch.
Formally, for each time step and each trajectory in the buffer, we compute a key κ i,j by using a linear projection with matrix W eret on the forward summaries h : κ i,j = ( h ij W eret ) T .
Each query q kt is then matched with the set of all keys κ i,j , forming attention logits 2 (cid:96) ki,j = (cid:16) q kt κ i,j √ d e (cid:17) and corresponding attention weights α ki,j = softmax (cid:0) (cid:96) ki,j (cid:1) , i ≤ n traj , 0 ≤ j ≤ T .
Intuitively, α ki,j captures the extent to which the j th timestep of the i th trajectory in the buffer will be relevant to memory m kt through the query q kt .
It follows that (cid:80) j α ki,j is a measure of how relevant the i th trajectory is as a whole for q kt .
Following previous work (Ke et al., 2018; Goyal et al., 2019b), matching only on the most relevant trajectories will increase the robustness of the retrieval mechanism.
We therefore select, for each query, the set T kt of k traj trajectories with highest aggregated score (cid:80)
j α ki,j .
Note that typically the queries corresponding to different slots will select different top- k traj trajectories from the retrieval batch.
Following the selection of relevant trajectories, we renormalize the weights α , and use a top- k mechanism once-again, this time to choose the set of most relevant states S kt (i.e. which maximizes (cid:80) i ∈T kt α
i,j ).
Step 3: Information retrieval from the most relevant trajectories and states (Figure 5B).
The next step of the retrieval mechanism consists in computing the renormalized weights α on the subsets T kt and S kt ( α ki,j = softmax (cid:0) (cid:96) ki,j (cid:1) , i ∈ T kt , j ∈ S kt ) and use those weights to compute the ﬁnal retrieved information.
The value retrieved from the buffer for query q kt is computed as the α -weighted average of a linear function of the backward state summaries: g kt = (cid:80) i,j α ki,j v i,j where v i,j = b i,j W vret .
Step 4: Regularization of the retrieved information via an information bottleneck.
We regularize the retrieved information g k t via the use of an information bottleneck (Tishby et al., 2000; Alemi et al., 2016); intuitively, each query pays a price of to exploit information from the retrieval batch.
Formally, we parametrize two Gaussian distributions p
( Z | g kt ) (which has access to the retrieved information) and r ( Z | m t − 1 ) (which only has access to the memory units).
We deﬁne z kt as a single sample from p ( Z | g kt ) via the reparameterization trick to ensure differentiability (Kingma & Welling, 2013; Rezende et al., 2014), and ensure that z kt does not contain too much information by adding an additional loss D KL ( p || r ) to the overall agent loss.
We provide more details in the appendix.
Step 5: Slot update.
The representation of each slot is ﬁrst additively updated as a function of the retrieved information (cid:102) m kt ← (cid:99) m kt − 1 + z kt .
The ﬁnal update m kt consists in an update in which all slots interact through self-attention (as normally done in Transformers)
(see Algorithm 1 for details).
Step 6: Updating the agent state using retrieved information.
The primary goal of the retrieval process is to extract information which may be useful for the agent process.
Here, we use the retrieved information to change the state of the agent s t .
In the previous step, the retrieved information is used to change the state of the slots.
For this step, we use a similar attention mechanism.
Here, the query is a function of the state of the agent process d t = s t W q ag , which are matched with the keys κ k = ( z kt W e ag ) T ∀ k ∈ { 1 , . . . , n f } , as a result of retrieving information, forming attention weights γ k = softmax (cid:16) d t κ k √ d e (cid:17) .
The values generated as a result of retrieved information by different slots and the attention weights are then used to update the state of the learning agent : u t ← (cid:80) k γ k v k where v k =
z kt W v ag ∀ k ∈ { 1 , . . . , n f } .
u t is the result of the attention over the retrieved information which is then used to change the representation of the agent process : (cid:101) s t ← s t + u t .
We also shape the representation of the action-value function Q ( s t , z kt , a t ) by conditioning the value function on the retrieved information z kt (again via a similar attention mechanism).
E XPERIMENTAL R ESULTS
To evaluate R2A, we analyze its performance in three different settings.
First, we evaluate on the
Atari arcade learning environment (ALE) (Bellemare et al., 2013), a single-task off-policy setting where the retrieval process extracts relevant information from the agent’s current replay buffer.
We then run a series of ablations of R2A to better understand the roles and effects of its components.
Second, we evaluate on a multi-task, ofﬂine environment that we created, called gridroboman .
In this environment, a single network is trained on data from all tasks and then, at evaluation time, the retrieval process queries a retrieval dataset containing only data from the task being evaluated.
Third, we evaluate R2A in a multi-task ofﬂine version of the BabyAI environment (Chevalier-Boisvert et al., 2018).
Again, a single network is trained on all tasks but now the retrieval process queries a retrieval dataset containing data from all tasks.
In our experiments, the retrieval process selects the top k traj = 10 most relevant trajectories (step 2, section 2.3), and then retrieves relevant information from the selected trajectories (step 3, section 2.3) using the top k states = 10 most relevant states.
To summarize the experiences in the retrieval batch we use a forward and backward GRU with 512 hidden units.
To train the representation of these, we use auxiliary losses in the form of action, reward, and value prediction (section 2.2).
See the section A. in appendix for more details about the experimental setup and training losses.
3. A TARI : S INGLE - TASK OFF - POLICY RL
In this ﬁrst experiment, our goal is to evaluate whether retrieval augmentation improves the performance and sample efﬁciency of a strong, recurrent baseline agent on a challenging, visually-complex environment—the Atari 2600 videogame suite (Bellemare et al., 2013).
We use recurrent replay distributed DQN (R2D2, Kapturowski et al.
as the baseline agent and compare retrievalaugmented R2D2 (RA-R2D2) to vanilla R2D2.
The retrieval dataset is the agent’s current replay buffer.
The agent process is parameterized as an GRU (Hochreiter & Schmidhuber, 1997), and the retrieval process is parameterized as the slot-based recurrent architecture described in Section 2, using 8 slots.
We randomly sample a retrieval batch consisting of 256 trajectories from the retrieval dataset.
In ﬁgure 2 we report the relative improvement of RA-R2D2 versus the R2D2 baseline.
We observe an increase of 11 .
32 ± 1 .
2 % in the mean human normalized score relative to the R2D2 baseline over 2 billion environment steps, demonstrating that retrieval augmentation is quite beneﬁcial in Atari and that the agent’s own replay buffer is a useful source for retrieval.
Raw scores and training curves are presented in appendix A.3.
3.1. A BLATIONS AND ANALYSIS
To understand the beneﬁt of different components of retrieval augmentation, we ablate RA-R2D2 on the 10 Atari games it performs best relative to R2D2.
The ablations are as follows.
Importance of a separate retrieval process (A-1).
In R2A, the retrieval process and the agent process are parameterized separately, i.e., they have their own internal states.
Here we examine what happens when the agent’s state is used to query the retrieval batch instead of using the retrieval state m t .
To implement this we modify
Step 1 of Algorithm 1 to make the query a direct function of the state of the agent, q t = f query ( s t ) .
The resulting query is used in the same way as above.
This is similar to the episodic control baseline of (Pritzel et al., 2017).
Importance of retrieving information (A-2).
We examine what happens when the retrieval process does not have access to the retrieval dataset and hence no information is retrieved, keeping all else the same.
In this ablation, the retrieval process updates the state of the slots using a transformer (i.e., in Step 1 we replace GRU with a transformer), and the updated state of the transformer is used by the agent process to shape the representation of its value function.
Shorter retrieved trajectories (A-3).
We decrease the length of the trajectories that are retrieved and summarized during retrieval pre-processing, thus reducing the amount of past and future information the retrieval process can retrieve.
By default, the trajectories in the retrieval dataset are of length 80.
To perform this ablation, we decrease the length of the effective context to only include information from 5 timesteps.
Importance of auxiliary losses to summarize retrieval batch (A-4, A-5).
Here we study the use of self-supervised BERT style masking losses in addition to using action, reward and value prediction.
We use these auxiliary losses on top of the representation learned by the forward and the backward dynamics model.
To implement these losses, we randomly mask 15% of the hidden states in a trajectory, and then using the representation of hidden states at other time-steps, we predict the representation of masked hidden states.
In A-5 , we study using only self-supervised BERT style masking losses for summarizing the trajectories.
Figure 3 shows the performance of RA-R2D2 and each ablation relative to the R2D2 baseline.
Ablation A-1 shows that it is crucial to parameterize the agent process and retrieval process separately, as using the agent state does no better than the baseline.
Ablation A-2 shows that the retrieval process ﬁnds relevant information that is useful to the agent.
It also shows that the performance gains of R2A are not simply due to an increase in model capacity but depend on retrieving information from the retrieval dataset.
Ablation A-3 shows that decreasing the length of the context in the retrieval dataset results in worse performance, thus showing the importance of our forward and backward trajectory summarization.
Ablation A-4 demonstrates that the performance of R2A can further be improved by incorporating BERT style auxiliary losses but that only using BERT style auxiliary losses results in worse performance (but still better than the baseline R2D2).
For completeness, Figure 10 in the appendix repeats the ablations on the 5 games that RA-R2D2 performs worst (relative to R2D2).
The main takeaway is that the performance of the R2A can be greatly improved by optimizing hyperparameters for each game separately (A-6), which we did not do for our experiments.
3. G RIDROBOMAN : M ULTI - TASK OFFLINE RL WITH A TASK - SPECIFIC RETRIEVAL DATASET
Beyond querying the agent’s own experiences, retrieval can provide helpful information from other sources of experiences, including experts or other agents as the case in ofﬂine RL where the agent must learn from a ﬁxed dataset of experiences generated by other agents without interacting with the environment during training.
A major challenge in ofﬂine RL is distributional shift—the mismatch
[Figure]
between the distribution of states in the training data and those visited by the agent when acting— which makes it difﬁcult to learn an accurate value function for states and actions rarely seen during training.
We hypothesize that the retrieval process can improve performance in the ofﬂine setting by retrieving trajectories (including states, actions, and rewards) relevant to the agent’s current state, particularly for states and actions that are rare in the ofﬂine dataset.
We test this hypothesis on a multi-task ofﬂine RL setup where a single agent is trained on multiple tasks simultaneously but at training and evaluation time the retrieval dataset contains only trajectories from the evaluated task.
For this experiment, we created a minimalistic grid-world-based robotic manipulation environment (gridroboman) with 30 tasks related to the three objects (red, green, and blue) on the board.
Gridroboman is built on the pycolab game engine (Stepleton et al.).
The environment is inspired by the challenges of robotic manipulation, and includes tasks such as “go to object X” and “put object
X on object Y”.
Details of the environment, its tasks, and an example ﬁgure are presented in the appendix (section A.4).
Here, we incorporate retrieval augmentation into a vanilla DQN agent as agent-state-recurrence is not needed for this task.
Figure 4 shows the results of training retrievalaugmented DQN (RA-DQN, orange) and DQN (blue) on increasing numbers of tasks.
With fewer tasks, RA-DQN and DQN perform identically; however, when the number of training tasks increases the retrieval-augmented agent is able to learn much more effectively than the baseline agent.
Training on more tasks requires either additional model capacity or the ability to extract information from fewer relevant samples for each task.
By directly querying task-relevant experiences in the ofﬂine dataset, retrieval augmentation improves sample efﬁciency.
Note that while the retrieval process does afford extra model capacity to the agent directly, ablation A-2 in section 3.1.1 shows that the retrieved information is what is crucial to performance, not the increased capacity.
3. B ABY AI: M ULTI - TASK OFFLINE RL WITH A MULTI - TASK RETRIEVAL DATASET
In this third experiment, our goal is to evaluate the beneﬁt of retrieval augmentation when data from other tasks is present in the retrieval dataset.
Multi-task retrieval data can be either harmful if the retrieved information misguides the agent or beneﬁcial if information from the other tasks is relevant to the current task.
Due to the use of attention in the retrieval process, we hypothesize that R2A will be able to ignore distracting information and retrieve relevant information from other tasks.
To test our hypothesis, we use the BabyAI environment (Chevalier-Boisvert et al., 2018), a partially observable multi-room grid world in which harder tasks are composed of simpler tasks and are formulated using subsets of a synthetic language.
At the start of each episode, the agent is placed in a random room and must navigate to a randomly located goal.
Due to the partial observability, we use a recurrent DQN (RDQN) agent as the baseline and compare its performance to a retrieval-augmented
RDQN (RA-RDQN) agent.
As is common in this environment, we measure the success rate of each agent, deﬁned as the ratio of tasks the agent was able to accomplish given a ﬁxed number of steps for each task.
Table 1 shows the performance of RA-RDQN with a multi-task replay, RA-RDQN with a replay speciﬁc to the current task, and the baseline for varying amounts of ofﬂine training data ( 50 K trajectories per task versus 200 K trajectories per task).
As expected from the previous experiment, retrieval augmentation improves performance over the baseline when using a single-task replay.
Performance further improves when using a multi-task replay.
We believe that this is due to [Table] the compositional nature of tasks in BabyAI, where retrieving information about the current subtask is more informative than retrieving information about the overall task.
R ELATED W ORK
Episodic control.
The idea of allowing deep RL agents to adapt based on past experiences using a non-parametric memory is not new (Blundell et al., 2016; Pritzel et al., 2017; Hansen et al., 2018;
Eysenbach et al., 2019; van Hasselt et al., 2019).
The basic idea is that the agent is equipped with an episodic memory system, which is used to remember and recall past experiences to inform decisions.
There are two important differences between R2A and these methods.
In these methods, a local action-value function is constructed by using information about the nearest neighbors in the replay buffer, and then the agent makes a decision about which action to execute based on both the local value function as well as the global value function.
However, in the proposed work, we employ a parameterized network (the retrieval process), which has access to the information in the replay buffer, and the agent process uses the retrieved information to shape the predictions of its value function in a fully differentiable way (using attention).
In these episodic control methods, there is only one process (the agent), which has direct access to the replay buffer.
However, in R2A, the agent process only has indirect access to the replay buffer via the retrieval process.
Separation of concerns.
In Hierarchical RL (HRL) (Heess et al., 2016; Frans et al., 2017; Vezhnevets et al., 2017; Florensa et al., 2017; Hausman et al., 2018; Goyal et al., 2019c), there’s separation of concerns among different policies, each policy focuses on a different aspect of the task, e.g., giving task relevant information to the high level policy only such that low level policy learns behaviours that are task agnostic.
In these methods, the high level policy shapes the behaviour of low level policy by either inﬂuencing representations or by inﬂuencing rewards.
It is possible to view our work through an analogous lens: wherein the “retrieval process” is the higher level policy (and has access to the all the information in the replay buffer) and is inﬂuencing the representation of the agent process that is interacting with the environment.
However, there are also notable differences in our work—for instance, the agent process also directly shapes the representation of the retrieval process, which is generally not the case in HRL (e.g., in Vezhnevets et al.
(2017) the manager directly inﬂuences the worker, but the worker does not directly inﬂuence the manager).
Retrieval in language models.
Several retrieval-based methods have recently been developed for question answering, controllable generation, and machine translation (Guu et al., 2020; Lee et al., 2019; Lewis et al., 2020; Sun et al., 2021).
The general scheme in such methods is to combine a parametric model (like a BERT-style masked language model or a pre-trained seq2seq model) with a non-parametric retrieval system.
They show that such models generate diverse and factually correct language than the state of the art parametric only baselines.
These methods share some similarities with our proposed model since they all involve a retrieval component but focus on different domains.
Additional related work is discussed in the appendix (section A.1).
C ONCLUSION .
In this work, we developed R2A, an algorithm that augments an RL agent with a retrieval process.
The retrieval process and the agent have separate states and shape the representation and predictions of each other via attention.
The goal of the retrieval process is to retrieve useful information from a dataset of experiences to help the agent achieve its objective more efﬁciently and effectively.
We show that R2A improves sample efﬁciency over R2D2, a strong off-policy agent, and compensates for insufﬁcient capacity when training in a multi-task ofﬂine RL environments.
Multiple ablations show the importance of the different components of R2A, including retrieving information from past experiences and parameterizing the agent and retrieval process separately instead of giving the agent process direct access to the replay buffer.
A A PPENDIX C ONTENTS
A.1 Extended Relevant Work
A.2 Information Theoretic Formulation
A.3 Atari: Implementation details and raw scores for R2D2 and RA-R2D
A
[Table] .1 Retrieval Process: Retrieving information from the retrieval buffer A
[Table]
on
[Table] [Table]
Additional
[Table]
ablations
A
[Table]
Gridroboman environment
A
Gridroboman experiment setup
A
[Table]
Gridroboman hyperparameters
A.4.3 Gridroboman evaluation curves when training on all 30 tasks
A.5 BabyAI environment
A.6 Limitations and Future Work
A.7 Social Impact A Rebuttal
Phase
A. E XTENDED R ELEVANT W ORK .
Model-based RL.
Their are different ways to integrate knowledge across past experiences.
One of the most common way is by learning a model of the world, and using the predictions from the model to improve the policy and the value function (Sutton, 1991; Silver et al., 2008; Silver, 2009;
Allen & Koomen, 1983; Silver et al., 2016; Racanière et al., 2017; Silver et al., 2018;
Springenberg et al., 2020; Schrittwieser et al., 2020).
To integrate information across different episodes (potentially separated by many time-steps), a model may needed be unrolled for many time-steps leading to compounding errors.
In R2A, the agent has direct access to the information in the retrieval dataset, and querying across multiple trajectories (in parallel) in the retrieval dataset potentially separated by hundreds of time-steps.
Structural Inductive Biases.
Deep learning have proposed structural inductive biases such as
Transformers (Vaswani et al., 2017; Dehghani et al., 2018; Radford et al., 2019; Chen et al., 2020a;b;
Dosovitskiy et al., 2020) or slot based recurrent architectures (Battaglia et al., 2016; Zambaldi et al., 2018; Battaglia et al., 2018; Goyal et al., 2019b; Watters et al., 2019; Goyal et al., 2020b; Veerapaneni et al., 2020; Goyal et al., 2021) where the induced structure has improved generalization, model-size scaling, and longrange dependencies.
Reinforcement Learning with Ofﬂine Datasets.
Recent work in RL has tried exploiting large datasets collected across many tasks to improve the sample efﬁciency of RL algorithms (Vecerik et al., 2017;
Pertsch et al., 2020; Nair et al., 2020; Siegel et al., 2020).
An advantage of such large datasets is that they can be collected cheaply, and can then be reused for learning many downstream tasks.
A general scheme for exploiting information about such task-agnostic datasets is either using them to directly improve the value function, or by extracting a set of skills or options and learning new tasks by recombining them.
In our work, we try to use information in the replay buffer by querying and searching for the relevant information across multiple trajectories which otherwise would take many replays through coincidentally relevant information for this to occur.
Efﬁcient Credit assignment.
Learning long term dependencies requires assigning credit to timesteps far back in the past.
Common methods for assigning credit in dynamics model like backpropagation through time requires information to be propagated backwards through every single step in the past.
This could become computationally expensive when used with very long sequences.
Methods which try to get around this problem only back-propagate information through a selected time-steps in the past, realized by a learned mechanism that associates current state with relevant past states (Ke et al., 2018; Wayne et al., 2018; Arjona-Medina et al., 2018; Goyal et al., 2018;
Fortunato et al., 2019).
Most of these works consider assigning credit to states within the same trajectory, whereas the proposed model R2A, searches for the relevant information in the replay buffer which includes information from other trajectories also.
A. I NFORMATION T HEORETIC F ORMULATION
Let’s denote the agent’s policy π θ ( A | S, G ) , where S is the agent’s state,
A the agent’s action,
G the information from the retrieval process conditioned on the current state of the agent i.e.,
G = f retrieval ( S ) , and θ the parameters of the neural network representing the policy.
We want to train agents that in addition to maximizing reward, minimize the policy dependence on the information from the retrieval process, quantiﬁed by the conditional mutual information
I ( A ; G | S ) .
This approach of minimizing the dependence of the policy on the information from the retrieval process can be interpreted as encouraging agents to learn useful behaviours and to follow those behaviours closely, except where diverting from doing so (as a result of using information from the retrieval process) leads to higher reward (Strouse et al., 2018;
Teh et al., 2017; Goyal et al., 2019a;
Galashov et al., 2019; Czarnecki et al., 2019).
To see this, note that the conditional mutual information can also be written as I ( A ; G | S ) =
E π θ [ D KL
[ π θ ( A | S, G ) | π 0 ( A | S )]] where E π θ denotes an expectation over trajectories, π 0 ( A | S ) =
(cid:80) g p ( g ) π θ ( A | S, g ) . is a “default” policy with the information from the retrieval process marginalized out.
We maximize the following objective:
[Equation]
where β > 0 is a tradeoff parameter, E π θ denotes an expectation over trajectories (for ex. generated by the agent’s policy) and D KL refers to the Kuhlback-Leibler divergence.
(Goyal et al., 2019a; Galashov et al., 2019) proposes to optimize the Eq. 1 by maximizing the lower bound ˜ J ( θ ) 3 :
[Equation]
We parameterize the policy π θ ( A | S, G ) using an encoder p enc ( Z | S, G ) , a decoder p dec ( A | S, Z ) and the q ( Z | S ) is the learned prior such that π θ ( A | S, G )
=
(cid:80) z p enc ( z | S, G ) p dec ( A | S, z ) .
The encoder output Z is meant to represent the information from the retrieval process that the agent believes is important to access in the present state S in order to perform well.
Due to the data processing inequality (DPI) (Cover, 1999)
I ( Z ; G | S ) ≥ I ( A ; G | S ) , and hence to obtain an upper bound on I ( Z ; G | S ) , we must ﬁrst obtain an upper bound on I ( Z ; G | S = s ) , and then average over p ( s ) .
We get the following result:
[Equation]
Such an information bottleneck has shown to improve generalization (Teh et al., 2017; Goyal et al., 2019a;c; Galashov et al., 2019; Merel et al., 2019; Liu et al., 2019; Goyal et al., 2020a;
Liu et al., 2021).
A. A TARI : I MPLEMENTATION DETAILS AND RAW SCORES FOR R2D2 AND RA-R2D2.
Table 3 shows the raw scores achieved by RA-R2D2 and the R2D2 baseline.
For R2D2 baseline and for the parameterization of the agent process, we follow the exact same training setup as in (Banino et al., 2021).
Figure 7, 8, 9, shows the learning curve for both the proposed model and the R2D baseline for different games.
Training Losses:
• The parameters of the state encoder are trained by the RL loss and the auxiliary losses used to train the forward/backward summarizer.
The state encoder encodes information about the past actions, past rewards and the current observation into an abstract state.
• The parameters of the retrieval process are trained by the RL loss and the information bottleneck regularizer.
• The parameters of the agent process are trained only by the RL loss.
Hyperparameters:
• At each learner step, the agent samples a large batch of 512 trajectories from the replay buffer.
A ﬁxed fraction of the batch ( 64 trajectories) is used for learning the Q-function and the remaining trajectories forms the retrieval batch.
• We sample a different retrieval dataset for each gradient update.
The re-encoding of the trajectories is performed for each gradient update during training.
• The retrieval process selects the top- k traj = 10 most relevant trajectories (in step 2, section 2.3), and then retrieves relevant information from the selected trajectories (step 3, section 2.3) using the top- k states = 10 most relevant states (see 5).
• To summarize the experiences in the retrieval batch we use a forward and backward GRU with 512 hidden units.
• We use 8 slots for Atari-R2D2 experiments.
• We use auxiliary losses in the form of action or policy prediction (section 2.2).
We follow the same setup as proposed in (Schrittwieser et al., 2020).
• The value of the β coefﬁcient for the information bottleneck regularizer is ﬁxed to 0 .
• The rest of the hyperparameters for R2D2 are taken from Kapturowski et al.
and are detailed in table
[Table]
Implementation details:
• We use GRU style gating and layernorm whenever we are changing the state of the agent process or the state of the slots in a residual way (Step 5, 6 in Algorithm 1).
• If the input to a neural network f nn consists of two tensors x, y , we never concatenate the inputs to the neural network.
We make use of attention.
We assume one of the inputs is the primary input (lets say x ), and other input is privileged input (as a result of doing some expensive computation, let’s say y ).
First, we compute f nn ( x ) , and then using the output of this computation, we cross-attend over y using multi-head attention.
• When computing the forward summary of the trajectories in the retrieval batch h
= h t + s t , we also add the information about the current encoded state i.e., s t .
Visual Encoder Visual observations are encoded using a ResNet-47 encoder.
The 47 layers are divided in 4 groups which have the following characteristics:
• An initial stride-2 convolution with ﬁlter size 3 x 3 ( 1 · 4 layers).
• Number of residual bottleneck blocks (in order): (2 , 4 , 6 , 2) .
Each block has 3 convolutional layers with ReLU activations, with ﬁlter sizes 1 x 1 , 3 x 3 , and 1 x 1 respectively ( (2+4+6+2) ·layers).
• Number of channels for the last convolution in each block: (64 , 128 , 256 , 512) .
• Number of channels for the non-last convolutions in each block: (16 , 32 , 64 , 128) .
• Group norm is applied after each group, with a group size of 8 .
After this observation encoding step, a ﬁnal layer with ReLU activations of sizes 512 is applied.
Computational Complexity.
Here we discuss the computational complexity of the R2A.
The following computations are happening at each step within a trajectory:
• A particular slot selects the relevant trajectories and relevant states at each time-step.
• We use an attention mechanism to select the set of relevant trajectories and relevant states.
This process scales with the number of trajectories in the retrieval batch.
• The set of relevant trajectories and relevant states changes across different time-steps within a trajectories.
This process is repeated for all the slots independently, but can be efﬁciently performed on GPUs/TPUs.
We can make following optimizations to reduce the computational complexity of the R2A
• For Atari and Gridroboman experiments instead of using a learned attention mechanism to rank the trajectories (in step 2, section 2.3), we can also just use those trajectories which are of high return (Abdolmaleki et al., 2018) since we already know that the data in the retrieval dataset is speciﬁc to the task on which we are training the agent.
• Once we have selected relevant trajectories, we can further reduce the computational cost of selecting most relevant states (in the selected trajectories) by only considering those states which are semantically similar to the agent’s current state.
Improvements tried that seem to improve the performance but were not evaluated exhaustively:
• Instead of performing only single step of retrieval at each step, we can also query the replay buffer multiple times within a time-step at the cost of increased computational complexity.
• We can allow different slots to retrieve information at different time scales.
We note that all of the hyperparameters for the retrieval process, except for the number of trajectories in the retrieval batch, remain the same across all experiments (Atari, gridroboman, and BabyAI).
A.3. R ETRIEVAL P ROCESS : R ETRIEVING INFORMATION FROM THE RETRIEVAL BUFFER .
Here we discuss the different steps involved in retrieving information from the retrieval buffer:
Query computation.
Each slot independently computes its prestate using the contextual information from the agent using a GRU.
Then, each slot independently computes a retrieval query which will be matched against information in the retrieval buffer.
Identiﬁcation of most relevant trajectories and states for each slot.
The retrieval mechanism process uses an attention mechanism to match a query produced by the the retrieval state associated with each slot to keys computed on each time step of each trajectory of the retrieval batch.
This process assigns a single scalar to each state within a trajectory.
These scores are used to assign a scalar to each trajectory and then normalized across trajectories.
These normalized scores are then used by the retrieval process to select the top- k traj most relevant trajectories (see Figure. 5).
The process is then again repeated to select most relevant states with the selected trajectories.
Here, a single scalar is assigned to each state with in selected trajectories and then normalized across all the states.
These scores are then used to select most relevant states within the most relevant trajectories.
Information retrieval from the most relevant states.
In the previous step, we selected most relevant states within the most relevant trajectories.
Now we integrate information across the selected states.
We again use the attention mechanism.
Here the query by the slots is matched against the keys (which are the function of the forward running dynamics model), to retrieve information about the future (and values are the function of the backward running dynamics model).
See ﬁgure.
6 for more details.
[Table]
A.3. D ETAILS ON ABLATIONS
Ablation A-1 : In this ablation, the internal retrieval state, m t is removed.
The query q t is computed from s t directly as q t = f query ( s t ) .
The retrieval vector g t is computed as per steps 2-4 of the original algorithm.
Step 5 does not occur, and in step 6 the only update is s t ← s t + g t .
Ablation A-2 :
In this ablation, there is no retrieval batch.
The retrieval process is parametrized as before with a n k -slot memory.
Step 1 is identical, but steps 2-4 do not occur.
Memory slots are updated as per the joint update of step 5.
Step 6 is otherwise identical, except that keys and values are computed from the memory slots m kt instead of the retrieved values z kt .
Ablation A-3 : In this ablation, the length of the trajectories used for summarization is reduced from 80 to 5 .
The trajectories used for Q learning are unchanged.
Ablations A-4 and A-5 :
In our experiments, we use standard policy, reward and value prediction cross-entropy losses (Schrittwieser et al., 2020) to train the forward and backward summarizers.
In
A-4, we add a BERT loss; tokens are obtained by compressing the agent states s t with VQ-VAE.
In
A-5, we only use the BERT loss.
A.3. A DDITIONAL A TARI ABLATIONS
Here we perform ablations on RA-R2D2 using the 5 Atari games on which RA-R2D2 performs worst relative to baseline R2D2.
Figure.
10 shows the relative performance of different ablations compared to the R2D2 baseline.
Ablations 1 - 5 are as described in the main text (section 3.1.1).
For these results, we also ran a sixth ablation.
Role of k traj and k states (A-6).
In our experiments, the retrieval process selects the top k traj =most relevant trajectories (step 2, section 2.3) and then selects the top k states = 10 most relevant states of these trajectories (step 3, section 2.3) from which to retrieve relevant information.
To better understand the role of these hyperparameters, we independently vary these two hyper-parameters (top k traj and top k states ) over the values { 5 , 10 , 20 } .
Figure 10 shows that after independently varying these two hyper-parameters the performance of the R2A can be improved as compared to the R2D baseline.
[Figure] [Figure]
[Figure] [Figure]
In order to test our method in a multi-task setting we designed a minimalistic grid world robotic manipulation ( gridroboman ) environment with a single embodiment and multiple tasks.
It is implemented based on the pycolab (Stepleton et al.)
game engine that provides tools for designing customizable grid world games.
The environment and its tasks are inspired by the challenges in robotic manipulation.
An illustration of a state in the environment is shown in Figure 4.
Environment semantics, observations and actions There are three colored objects on the 7 ×board: red, green and blue.
The black block represents the robot.
It can move in 4 directions and the action is skipped if it attempts to move into a wall (gray).
Additionally, if the robot is located at the same position as any colored object, it can apply lift action that would enforce the object to move together with the robot.
Then, put action allows to position the object either on the board or on the top of another single object.
Additionally, there is an option of skipping an action.
The initial state of the environment that includes positions of the objects and the robot is sampled randomly at the beginning of each episode.
The agent observation is an 11 -dimensional vector: it includes x and y coordinates of three objects and the robot as well as status of each of three objects.
The status of an object is a numerical value: 0 if the object is positioned on the board, − 1 if it is under another object and +1 if it is either held by the robot or located on the top of another object.
Each episode lasts for 50 timesteps.
Tasks There are 30 possible tasks: lift red, green, or blue object ( 3 ), touch red, green, or blue object ( 3 ), move red, green, or blue to center ( 3 ) or to corner ( 3 ), touch one object with another ( 6 ), move two objects close to ( 3 ) or far from ( 3 ) each other, stack one object on the top of another ( 6 ).
The nature of these tasks is such that it is impossible to identify the task by the initial state.
Rewards The reward is binary in each time step: it is zero when the task is not solved and one otherwise.
In order to receive positive reward the following condition should be met:
• lift X : the robot should lift and not put back an object of color X; • touch X : the robot should be located at the immediately adjacent cell to the object of X color and not hold any objects; • move X to center : the object or color X should be located in the 3 × 3 block at the center of the board; • move X to corner : the object of X color should be located in any of the 2 × 2 corners of the board; • touch X with Y : the robot should be located at the immediately adjacent position to the object of X color and hold the object of color Y; • move X close to Y : the distance between the objects of colors X and Y should be no more than 1 in both x and y direction;
• move X far from Y : the sum of distances between objects of colors X and Y in x and y coordinated should be greater than 9 ; • stack X on Y : the objects of colors X
and Y should be located at the same position one on the top of another.
A.4. G RIDROBOMAN EXPERIMENT SETUP
The gridroboman ofﬂine RL dataset was generated by training a single DQN agent online on each task separately and recording the 100 K generated episodes.
The Q ( s, a ) network was a 3 -layer MLP with 256 units in each hidden layer for Q-function.
For the experiments with 10 , 20 , and 30 tasks, we use the ﬁrst 10 , 20 , and 30 tasks, as listed here.
10 tasks: touch red, touch green, touch blue, lift red, lift green, lift blue, red touch green, green touch red, and green touch blue.
20 tasks:
The above 10 tasks, blue touch red, blue touch green, red to corner, green to corner, blue to corner, red to center, green to center, blue to center, red close to blue, and red close to green.
30 tasks:
The above 20 tasks, blue close to green, red far from blue, red far from green, blue far from green, red on blue, red on green, green on red, green on blue, blue on red, and blue on green.
A.4. G RIDROBOMAN HYPERPARAMETERS
The DQN agent used the same network as used to create the data: a 3 -layer MLP with 256 hidden units per layer.
The ﬁrst 2 layers deﬁne f enc θ and the ﬁnal layer predicts Q. The RA-DQN agent used the same base network plus a separate retrieval network.
Below we detail hyperparameters speciﬁc to gridroboman.
Hyperparameters not speciﬁed in this section are the same as used in Atari.
• At each learner step, the agent samples a batch of 256 states from the replay buffer to train the DQN agent and further samples a batch of 64 trajectories from the retrieval dataset to form the retrieval batch.
• The retrieval process selects the top- k traj = 10 trajectories with the highest return, and then retrieves relevant information from the selected trajectories (step 3, section 2.3) using the top- k states = 10 most relevant states.
• To summarize the experiences in the retrieval batch we use a forward and backward GRU with 256 hidden units.
• We use 4 slots to parameterize the retrieval process.
• We use auxiliary losses in the form of value, reward, and policy prediction (section 2.2).
We follow the same setup as proposed in (Schrittwieser et al., 2020) and weight these auxiliary losses with a coefﬁcient of 0 . 1 .
• The value of the β coefﬁcient for the information bottleneck regularizer is ﬁxed to 0 .
• The hyperparameters and setup for ofﬂine DQN are taken from Gulcehre et al.
They are detailed in table 5.
As in the above, we used double DQN (Van Hasselt et al., 2016)
[Table]
[Figure]
G RIDROBOMAN EVALUATION CURVES WHEN TRAINING ON ALL 30 TASKS
Figure 12 we show the average episode reward obtained by the evaluation agent on each individual task when training on all 30 tasks.
Curves are shown for the DQN and RA-DQN agents.
[Figure] [Figure]
A. B ABY AI ENVIRONMENT .
Observations, actions.
We use the same setup for the observations and actions as in (ChevalierBoisvert et al., 2018).
Tasks.
We use all the 40 available tasks in the BabyAI environment.
5 https://github.com/mila-iqia/babyai/blob/master/docs/bonus_levels.md .
https://github
Hyper-parameters and RL algorithm.
We follow the same setup as in the Gridroboman experiments.
Since BabyAI is a partially observable environment, we summarize the history of the agent using a recurrent encoder.
[Table]
Retrieval Process.
We use the same hyper-parameters for the retrieval process as used in the gridroboman enviornment.
For the case of multi-task retrieval buffer, we use 32 trajectories corresponding to each task to form the retrieval batch.
A. L IMITATIONS AND F UTURE W ORK .
It would be useful to investigate and extend the proposed idea in these different ways: (a) First, investigate training of the retrieval process and the agent process using different objectives as compared to training them in an end-to-end fashion, (b) Second, scaling R2A to more complex problems multi-agent problems like in Starcraft (Vinyals et al., 2019), where one may have access to millions of past experiences.
In R2A, we only query a subset of the retrieval dataset, which limits the generality of the method.
(c) Third, even more intriguing would be the possibility of learning an abstract model with abstract internal actions, and rewards, rather than learning a model which queries for information from the retrieval dataset, and hence avoiding the need for Monte Carlo tree search common in the state of the art planning methods (Schrittwieser et al., 2020).
We aim to formulate these problems and seek answers in the future work.
A. S OCIAL I MPACT .
The authors do not foresee negative social impact of this work beyond that which could arise from general improvements in ML. A. R EBUTTAL P HASE .
Comparison to Episodic Control baselines.
We have performed ablations where we compared to the scenario where we just keep the simple episodic memory (refer to section.
3.1.1, ablation A-1).
The result of ablations shows that for R2D2 accessing the dataset in a non-parametric way actually hurts the performance of the RL algorithm.
BERT style unsupervised losses then not used generally in the R2A method BERT style unsupervised losses actually improve the learned representations.
We did not choose to use BERT style representations as they increase the number of design choices, increase the number of ablations, increase the number of parameters, whereas the relative gains of using BERT style unsupervised losses is not much.
Future work should investigate the use of pre-trained encoders as common in
NLP literature.
For Frostbite, episodic control is beneﬁcial.
As mentioned in “Building Machines That Learn and
Think Like People”, in Frostbite, players control an agent (Frostbite Bailey) tasked with constructing an igloo within a time limit.
The igloo is built piece-by-piece as the agent jumps on ice ﬂoes in water
The challenge is that the ice ﬂoes are in constant motion (moving either left or right), and ice ﬂoes only contribute to the construction of the igloo if they are visited in an active state (white rather than blue).
The agent may also earn extra points by gathering ﬁsh while avoiding a number of fatal hazards (falling in the water, snow geese, polar bears, etc.).
Success in this game requires a temporally extended plan to ensure the agent can accomplish a sub-goal (such as reaching an iceﬂoe) and then safely proceed to the next sub-goal.
Ultimately, once all of the pieces of the igloo are in place, the agent must proceed to the igloo and thus complete the level before time expires.
One hypothesis for the better performance could be that the retrieval process is able to efﬁcient utilize the information from the states which are very far apart from the current state (i.e., temporally extended credit assignment).
This hypothesis is further validated when we decrease the length of the traces in the dataset.
In ablation section, if we decrease the length of the trajectories that are retrieved and summarized during retrieval preprocessing, thus reducing the amount of past and future information the retrieval process can retrieve.
By default, the trajectories in the retrieval dataset are of length 80.
To perform this ablation, we decrease the length of the effective context to only include information from 5 time-steps.
Similar Computation baseline.
We also compared to a baseline which does the same amount of “computations” (Importance of retrieving information (A-2)).
We examine what happens when the retrieval process does not have access to the retrieval dataset and hence no information is retrieved, keeping all else the same.
In this ablation, the retrieval process updates the state of the slots using a transformer (i.e., in Step 1 we replace GRU with a transformer), and the updated state of the transformer is used by the agent process to shape the representation of its value function.
Since the use of the transformer number of parameters in this baseline is more as compared to R2D2.
Our results show that the proposed method R2A archives better performance as compared to vanilla
R2D2 as well as the baseline which does the same amount of computation (but does not retrieve information).
How does runtime compare to vanilla R2D2?
How many more parameters are introduced?
As compared to vanilla R2D2, a naive implementation of the proposed method is around 3x slow (and somewhat optimized implementation around 2x slower), with the increase of 10% more parameters.
In the ablations, we also examine what happens when the retrieval process does not have access to the retrieval dataset and hence no information is retrieved but everything else is kept the same (same computation and same parameter baseline).
Use of hierarchical attention (top- k trajectories and then top- k states).
A hierarchical attention where we ﬁrst ﬁlter trajectories, and then ﬁlter states reduces the search space for the attention.
For example.
consider 512 trajectories, and 80 states in each trajectory, then the attention operator has to select 10 most relevant states out of 40960 states.
Whereas if we do initial ﬁltering of top-k trajectories, then the attention operator needs to select 10 most relevant trajectories out oftrajectories, and then 10 most relevant states out of 800 states.
Such an hierarchical attention has also shown to be successful in various NLP tasks also.
Analysis about retrieved information in the multi-task setting?
We did some analysis to study the properties about the retrieved information in the multi-task setting in BabyAI.
BabyAI setup contains about 40 tasks.
Out of these 40 tasks, around 15 tasks are compositional i.e., requires to compose information from 2 or more sub-tasks, and rest of the tasks requires the agent to execute a particular behaviour (ex. going to the door, fetching a key etc).
We study as to how often the agent retrieves information from other tasks.
Ideally, for the compositional tasks, the hope would be the agent access information about the other tasks more often as compared to the tasks which require only a particular behaviour.
So, during test time, we study the percentage of times agent access information from the same task as compared to accessing information from the different tasks.
For compositional tasks, the agent access information from other tasks about 54% of times, while the percentage for single tasks is about 21%.
That said, we were not able to ﬁnd any pattern as to ﬁnd why the agent is retrieving more information from other tasks for some particular tasks as well as any structure about the states from which information is being retrieved.