Reinforcement Learning via Recurrent Convolutional Neural Networks

TL;DR

This paper introduces Recurrent Convolutional Neural Networks (RCNNs) for reinforcement learning, enabling explicit modeling of environment structure and improved planning in partially observable tasks.

Contribution

It presents a novel RCNN-based framework that learns transition and reward models, combining model-free and model-based RL advantages.

Findings

RCNNs effectively learn accurate MDP models

Framework reduces replanning costs in robot planning

Achieves near-optimal policies through learned models

Abstract

Deep Reinforcement Learning has enabled the learning of policies for complex tasks in partially observable environments, without explicitly learning the underlying model of the tasks. While such model-free methods achieve considerable performance, they often ignore the structure of task. We present a natural representation of to Reinforcement Learning (RL) problems using Recurrent Convolutional Neural Networks (RCNNs), to better exploit this inherent structure. We define 3 such RCNNs, whose forward passes execute an efficient Value Iteration, propagate beliefs of state in partially observable environments, and choose optimal actions respectively. Backpropagating gradients through these RCNNs allows the system to explicitly learn the Transition Model and Reward Function associated with the underlying MDP, serving as an elegant alternative to classical model-based RL. We evaluate the proposed algorithms in simulation, considering a robot planning problem. We demonstrate the capability of our framework to reduce the cost of replanning, learn accurate MDP models, and finally re-plan with learnt models to achieve near-optimal policies.

Figures

Equations

$$V_{k+1}(s)=\underset{a}{\max }R(s,a)+\gamma \overline{T}(s,a,s^{\prime })\ast V_k(s^{\prime })$$

$$b(s^{\prime })=\frac{O(s^{\prime },a,z){\sum }_{s\in S}T(s,a,s^{\prime })b(s)}{{\sum }_{s^{\prime }\in S}O(s^{\prime },a,z){\sum }_{s\in S}T(s,a,s^{\prime })b(s)}$$

$$b(s^{\prime })=\eta O(s^z)\odot T(s,a,s^{\prime })\ast b(s)$$

$${\mathbf{y}}_t^a=\frac{e^{Q(b(s),a)}}{{\sum }_a{e}^{Q(b(s),a)}}$$

Full text

I Introduction

Deep Reinforcement Learning (DRL) algorithms exploit model-free Reinforcement Learning (RL) techniques, to achieve high levels of performance on a variety of tasks, often on par with human experts in the same domain [1]. These DRL methods use deep networks to either approximate the action-value functions as in Deep Q Networks [1, 2, 3], or directly parametrizing the policy, as in policy gradient methods [4]. While DRL methods adopt model-free approaches in order to generalize performance across various tasks, it is difficult to intuitively understand the reasoning of DRL approaches in making a particular choice of action, since they often ignore the underlying structure of the tasks.

In contrast, model-based methods [5, 6, 7, 8] exploit this inherent structure to make decisions, based on domain knowledge. The estimates of the transition model and reward function associated with the underlying Markov Decision Process (MDP) are transferable across environments and agents [9], and provide insight into the system’s choice of actions. A significant deterrent from model-based RL is the indirect nature of learning with the estimated model; subsequent planning is required to obtain the optimal policy [10].

To jointly exploit this inherent structure and overcome this indirect nature, we present a novel fusion of Reinforcement and Deep Learning, by representing classical solutions to RL problems within the framework of Deep Learning architectures; in particular Recurrent Convolutional Neural Networks (RCNNs). By explicitly connecting the steps of solving MDPs with architectural elements of RCNNs, our representation inherits properties of such networks; allowing the use of backpropagation on the defined RCNNs as an elegant solution to model-based RL problems. The representation also exploits the inherent structure of the MDP to reduce the cost of replanning, further incentivizing model-based approaches.

The contributions of this paper are hence three-fold. We define a Value Iteration RCNN (VI RCNN), whose forward passes carry out Value Iteration to efficiently obtain the optimal policy. Second, we define a Belief Propagation RCNN (BP RCNN), to update beliefs of state via the Bayes Filter. Backpropagation through this network learns the underlying transition model of the agent in partially observable environments. Finally, we define a QMDP RCNN by combining the VI RCNN and the BP RCNN. The QMDP RCNN computes optimal choices of actions for a given belief of state. Backpropagation through the QMDP RCNN learns the reward function of an expert agent, in a Learning from Demonstration via Inverse Reinforcement Learning (LfD-IRL) setting [11]. The learnt reward function and transition model may then be used to re-plan via the VI RCNN, and the QMDP RCNN to make optimal action choices for new beliefs and the learnt Q-values. 111Please find our code and supplementary material at https://github.com/tanmayshankar/RCNN_MDP.

We note that [12] follows an approach mathematically similar to the VI RCNN; however it differs in being a model-free approach. The model-based approach followed here learns MDP models transferable across environments and agents. Further, the QMDP RCNN approach proposed here follows more naturally than the fully connected layer used in [12]. The gradient updates of the QMDP RCNN adopt an intuitive form, that further contributes to an intuitive understanding of the action choices of the QMDP RCNN, as compared to [12].

We evaluate each of the RCNNs proposed in simulation, where the given task is a 2-D robot planning problem. We demonstrate the capacity of the VI RCNN to reduce the cost of re-planning by significantly reducing the execution time as compared to classical Value Iteration. We evaluate the BP RCNN based on the accuracy of the learnt transition models against ground truth models, and show that it appreciably outperforms naive model-based methods for partially observable environments. Our experiments finally demonstrate that the QMDP RCNN is able to generate policies via re-planning with learnt MDP models, that accurately represent policies generated from ground truth MDP models.

II The Value Iteration RCNN

In this section, we formulate Value Iteration as a recurrent convolution, and hence present the Value Iteration RCNN (VI RCNN) to carry out Value Iteration. We consider a standard Markov Decision Process, consisting of a 2-dimensional state space $S$ of size $N_{d}\times N_{d}$, state $s\in S$, action space $A$ of size $N_{a}$, actions $a\in A$, a transition model $T(s,a,s^{\prime})$, reward function $R(s,a)$, and discount factor $\gamma$. Value Iteration, which is typically used in solving for optimal policies in an MDP, invokes the Bellman Update equation as $V_{k+1}(s)=\max_{a}\ R(s,a)+\gamma\sum_{s^{\prime}}T(s,a,s^{\prime})V_{k}(s^{\prime})$.

Value Iteration as a Convolution: In our 2-D state space, $S$, states $s$ and $s^{\prime}$ are defined by 2 pairs of indices $(i,j)$ and $(p,q)$. The summation over all states $s^{\prime}$ may hence be equivalently represented as $\sum_{s^{\prime}}=\sum_{p=1}^{N_{d}}\sum_{q=1}^{N_{d}}$. The transition model is hence of size $N_{d}^{2}\times N_{a}\times N_{d}^{2}$. We may express $V_{k+1}(s)$ as $\max_{a}R(s,a)+\gamma\sum_{p=1}^{N_{d}}\sum_{q=1}^{N_{d}}T(s,a,s^{\prime})_{p,q}V_{k}(s^{\prime})_{p,q}$.

Actions correspond to transitions in the agent’s state, dictated by the internal dynamics of the agent, or in the case of physical robots, restricted by the robot’s configuration and actuator capacities. It is impossible for the agent to immediately move from its current state to a far away state. This allows us to define a $w$ neighborhood centred around the state $s^{\prime}$, $W(s^{\prime})$, so the agent only has a finite probability of transitioning to other states within $W$. Mathematically, $T(s,a,s^{\prime})\neq 0$ if $|i-p|\leq w$ and $|j-q|\leq w$ or if $s\in W(s^{\prime})$, and $T(s,a,s^{\prime})=0$ for $s\not\in W(s^{\prime})$.

Further, the transition model is often invariant to the spatial location of the occurring transition. For example, a differential drive robot’s dynamics are independent of the robot’s position. We assume the transition model is stationary over the state space, incorporating appropriate state boundary conditions. We may now visualize this $w$ neighborhood restricted transition model itself to be centred around $s^{\prime}$. By defining a flipped transition model as: $\overline{T}(s,a,s^{\prime})_{m,n}=\ T(s,a,s^{\prime})_{N_{t}-m,N_{t}-n}$, and indexing it by $(u,v)$, we may express $V_{k+1}(s)$ as $\max_{a}R(s,a)+\gamma\sum_{u=-w}^{w}\sum_{v=-w}^{w}\overline{T}(s,a,s^{\prime})_{u,v}V_{k}(s^{\prime})_{i-u,j-v}$. We may represent this as a convolution:

[TABLE]

The Value Iteration RCNN: We define a Value Iteration RCNN (VI RCNN) to represent classical Value Iteration, based on the correlation between the Bellman update equation, and the architectural elements of an RCNN. Equation (1) can be thought of as a single layer of a recurrent convolutional neural network consisting of the following 4 stages:

Convolutional Stage: The convolution of $\overline{T}(s,a,s^{\prime})*V_{k}(s^{\prime})$ represents the convolutional stage. 2. 2.

Max-Pooling Stage: The maximum at every state $s$ taken over all actions $a$, $\max_{a}$ is analogous to a max-pooling stage along the action ‘channel’. 3. 3.

Fixed Bias Stage: The introduction of the reward term $R(s,a)$ is treated as addition of a fixed bias. 4. 4.

Recurrence Stage: As $k$ is incremented in successive iterations, $V_{k+1}(s)$ is fed back as an ‘input’ to the network, introducing a recurrence relation into the network.

We may think of $V_{k}(s^{\prime})$ as a single-channel $N_{d}\times N_{d}$ image. $\overline{T}(s,a,s^{\prime})$ then corresponds to a series of $N_{a}$ transition filters, each of $N_{t}\times N_{t}$ size ($N_{t}=2w+1$), each to be convolved with the image. The values of the transition filters correspond directly to transition probabilities between states $s$ and $s^{\prime}$, upon taking action $a$. Note that these convolutional transition filters naturally capture the spatial invariance of transitions by virtue of lateral parameter sharing inherent to convolutional networks. Further, in this representation, each transition filter corresponds directly to a particular action. This unique one-to-one mapping between actions and filters proves to be very useful in learning MDP or RL models, as we demonstrate in section III. Finally, the VI RCNN is completely differentiable, and can be trained by applying backpropagation through it.

III The Belief Propagation RCNN

In this section, we present the Belief Propagation RCNN (BP RCNN), to represent the Bayes filter belief update within the architecture of an RCNN, and hence learn MDP transition models. For an agent to make optimal choices of actions in partially observable environments, an accurate belief of state $b(s)$ is required. Upon taking an action $a$ and receiving observation $z$, we may use the Bayes filter to propagate the belief $b(s^{\prime})$ in terms of an observation model $O(s^{\prime},a,z)$, associated with probability $p(z|s^{\prime},a)$. The discrete Bayes filter is depicted in (2). Note the denominator is equivalent to $p(z|a,b)$, and can be implemented as a normalization factor $\eta$.

[TABLE]

Bayes Filter as a Convolution and an Element-wise Product: We may represent the motion update of the traditional Bayes filter as a convolution, analogous to the representation of $\sum_{s^{\prime}}T(s,a,s^{\prime})V_{k}(s^{\prime})$ step of Value Iteration as $\overline{T}$ $(s,a,s^{\prime})*V_{k}(s^{\prime})$ in equation (1). Transitions in a Bayes filter occur from $s$ to $s^{\prime}$, in contrast to the ‘backward’ passes executed in Value Iteration, from $s^{\prime}$ to $s$. This suggests our transition model is centred around $s$ rather than $s^{\prime}$, and we may represent $\sum_{s}$ as $\sum_{i=1}^{N_{d}}\sum_{j=1}^{N_{d}}$. We write the intermediate belief $\overline{b(s^{\prime})}_{p,q}$ as $\sum_{u=-w}^{w}\sum_{v=-w}^{w}T(s,a,s^{\prime})_{u,v}\ b(s)_{p-u,q-v}$, which can be expressed as a convolution $\overline{b(s^{\prime})}=T(s,a,s^{\prime})*b(s)$. For the Bayes Filter correction update, we consider a simple observation model $O(z,s^{\prime})$ for observation $z$ in state $s^{\prime}$. The agent observes its own state as $s^{z}_{x,y}$, indexed by $x$ and $y$, given that the actual state of the robot is $s^{\prime}_{i,j}$, with a probability $p(s^{z}_{x,y}|s^{\prime}_{i,j})$. Analogous to the $w$ neighborhood for the transition model, we introduce a $h$ neighborhood for the observation model, centred around the observed state $s^{z}_{x,y}$. Thus $O(s^{z}_{x,y},s^{\prime})\neq 0$ for states $s^{\prime}_{i,j}$ within the $h$ neighborhood $H(s^{z}_{x,y})$, and $O(s^{z}_{x,y},s^{\prime})=0$ for all $s^{\prime}_{i,j}\not\in H(s^{z}_{x,y})$.

The correction update in the Bayes filter can be represented as a masking operation on the intermediate belief $\overline{b(s^{\prime})}$, or an element-wise (Hadamard) product ($\odot$). Since the observation $O(s^{z})$ is also centred around $s^{z}$, we may express $b(s^{\prime})_{i,j}$ as $\eta\ O(s^{z})_{i-x,j-y}\ \overline{b(s^{\prime})}_{i,j}\ \forall\ i,j$, which corresponds to a normalized element-wise product $b(s^{\prime})=\eta\ O(s^{z})\odot\overline{b(s^{\prime})}$. Upon combining the motion update convolution and the correction update element-wise product, we may represent the Bayes Filter as a convolutional stage followed by an element-wise product. We have:

[TABLE]

The Belief Propagation RCNN: We define a Belief Propagation RCNN (BP RCNN) to represent the Bayes Filter belief update, analogous to the representation of Value Iteration as the VI RCNN. A single layer of the BP RCNN represents equation (3), consisting of the following stages:

Convolution Stage: The convolution $T(s,a,s^{\prime})*b(s)$ represents the convolution stage of the BP RCNN. 2. 2.

Element-wise Product Stage: The element-wise multiplication $O(s^{z})\odot\overline{b(s^{\prime})}$, can be considered as an element-wise product (or Hadamard product) layer in 2D. 3. 3.

Recurrence Stage: The network output, $b(s^{\prime})$, is fed as the input $b(s)$ at the next time step, forming an output recurrence network.

Forward passes of the BP RCNN propagate beliefs of state, given a choice of action $a_{t}$ and a received observation $z_{t}$. The belief of state at any given instant, $b(s)$, is treated as a single channel $N_{d}\times N_{d}$ image, and is convolved with a single transition filter $T_{a_{t}}$, corresponding to the action executed, $a_{t}$. A key difference between the VI RCNN and the BP RCNN is that only a single transition filter is activated during the belief propagation, since the agent may only execute a single action at any given time instant. The BP RCNN is also completely differentiable.

Training and Loss: Learning the weights of the BP RCNN via backpropagation learns the transition model of the agent. Our objective is thus to learn a transition model $T^{\prime}(s,a,s^{\prime})$ such that network output $b(s^{\prime})$ is as close to the target belief $\widehat{b(s^{\prime})}$ as possible, at every time step. Formally, we minimize a loss function defined as the least square error between both beliefs over all states: L_{t}=\sum_{i=1}^{N_{d}}\sum_{j=1}^{N_{d}}\ \big{(}\widehat{b(s^{\prime}_{t})}-b(s^{\prime}_{t})\big{)}_{i,j}^{2}, with conditions on the transition model, $0\leq T^{\prime}(s,a,s^{\prime})_{m,n}\leq 1$, and $\sum_{m=-w}^{w}\sum_{n=-w}^{w}T^{\prime}(s,a,s^{\prime})_{m,n}=1\ \forall\ a\in A$, being incorporated using appropriate penalties.

The BP RCNN is trained in a typical RL setting, with an agent interacting with an environment by taking random action choices $(a_{t},a_{t+1}...)$, and receiving corresponding observations, $(z_{t},z_{t+1}...)$. The target beliefs, $\widehat{b(s^{\prime})}$, are generated as one-hot representations of the observed state. While training the BP RCNN, the randomly initialized transition model magnifies the initial uncertainty in the belief as it is propagated forward in time, leading to instability in learning the transition model. Teacher forcing [13] is adopted to handle this uncertainty; thus the target belief, rather than the network output, is propagated as the input for the next time step. Since the target belief is independent of the initial uncertainty of the transition model, the network is able to learn a meaningful set of filter values. Teacher forcing, or such target recurrence, also decouples consecutive time steps, reducing the backpropagation through time to backpropagation over data points that are only generated sequentially.

IV The QMDP RCNN

We finally present the QMDP RCNN as a combination of the VI RCNN and the BP RCNN, to retrieve optimal choices of actions, and learn the underlying reward function of the POMDP (in addition to the transition model). Treating the outputs of the VI RCNN and the BP RCNN as the action-value function, $Q(s,a)$, and the belief of state, $b(s)$ respectively at every time step, we may fuse these outputs to compute belief space Q-values $Q(b(s),a)$ using the QMDP approximation. We have $Q(b(s),a)=\sum_{s\in S}Q(s,a)_{\tiny{MDP}}b(s)$, which may alternately be represented as a Frobenius Inner product ${\langle b(s),Q(s,a)\rangle}_{F}$. Optimal action choices $\mathbf{y}^{a}_{t}$, corresponding to the highest belief space Q-values, and can be retrieved from the softmax of $Q(b(s),a)$:

[TABLE]

The QMDP RCNN: In addition to the stages of the VI RCNN and BP RCNN, the QMDP RCNN is constructed from the following stages:

Frobenius Inner Product Stage: The QMDP approximation step $Q(b(s),a)={\langle b(s),Q(s,a)\rangle}_{F}$. represents an Frobenius inner product stage. This can be implemented as a ‘valid’ convolutional layer with zero stride. 2. 2.

Softmax Stage: $\mathbf{y}^{a}_{t}=softmax\ Q(b(s),a)$ represents the softmax stage of the network.

The resultant QMDP RCNN, as depicted in Figure 3, combines planning and learning in a single network. Forward passes of the network provide action choices $\mathbf{y}^{a}_{t}$ as an output, and backpropagating through the network learns the reward function, and updates Q-values and optimal action choices via planning through the VI RCNN component.

Training and Loss: The QMDP RCNN is trained in a Learning from Demonstration - Inverse Reinforcement Learning setting. An expert agent demonstrates a set of tasks, recorded as a series of trajectories $\{(a_{t},z_{t}),(a_{t+1},z_{t+1})...\}$, which serve as inputs to the network. The actions executed in the expert trajectories are represented in a one-hot encoding, serving as the network targets $\widehat{\mathbf{y}}^{a}_{t}$. The objective is to hence learn a reward function such that the action choices output by the network match the target actions at every time step. The loss function chosen is the cross-entropy loss between the output actions and the target actions at a given time step, defined as $C_{t}=-\sum_{a}{\widehat{\mathbf{y}}^{a}_{t}ln\mathbf{y}^{a}_{t}}$. The QMDP RCNN learns the reward function by backpropagating the gradients retrieved from this loss function through the network, to update the reward function. The updated reward estimate is then fed back to the VI RCNN component to update the Q-values, and hence the action choices of the network. Experience replay [14] is used to randomize over the expert trajectories and transitions while training the QMDP RCNN.

The closed form of the gradient for reward updates is of the form of $R(s,a)\xleftarrow{\alpha_{t}}-(\mathbf{y}^{a}_{t}-\widehat{\mathbf{y}}^{a}_{t})b(s)$. The $(\mathbf{y}^{a}_{t}-\widehat{\mathbf{y}}^{a}_{t})$ term thus dictates the extent to which actions are positively or negatively reinforced, while the belief term $b(s)$ acts in a manner similar to an attention mechanism, which directs the reward function updates to specific regions of the state space where the agent is believed to be.

We emphasize that the QMDP RCNN differs from traditional DRL approaches in that the QMDP RCNN is not provided with samples of the reward function itself via its interaction with the environment, rather, it is provided with action choices made by the expert. While the LfD-IRL approach employed for the QMDP RCNN is on-policy, the in-built planning (via the VI RCNN) causes reward updates to permeate the entire state space. The dependence of the LfD-IRL approach in the QMDP RCNN on expert-optimal actions for training differs from the BP RCNN, which uses arbitrary (and often suboptimal) choices of actions.

V Experimental Results and Discussions

In this section, experimental results are individually presented with respect to each of the 3 RCNNs defined.

VI RCNN: Here, our contribution is a representation that enables a more efficient computation of Value Iteration. We thus present the per-iteration run-time of Value Iteration via the VI RCNN, versus a standard implementation of Value Iteration. Both algorithms are implemented in Python, run on an Intel Core i7 machine, 2.13 GHz, with 4-cores. The inherent parallelization of the convolution facilitates the speed-up of VI by several orders of magnitude, as depicted in Figure 4; at best, the VI RCNN completes a single iteration $5106.42$ times faster, and at worst, it is $1704.43$ times faster than the regular implementation.

BP RCNN: The primary objective while training the BP RCNN is to determine an accurate estimate of the transition model. We evaluate performance using the least square error between the transition model estimate and the ground truth model, defined as $C^{\prime}_{t}=\sum_{a}\sum_{u}\sum_{v}{(T^{a}_{u,a}-T^{\prime a}_{u,v})}^{2}$. Since the final objective is to use these learnt models to generate new policies by replanning via the VI RCNN, we also present the replanning accuracy of each model; defined as the percentage of actions chosen correctly by the network’s policy, compared to the original policy. A comparison is provided against the models learnt using a counting style algorithm analogous to that used in [15], as well as a weighted-counting style algorithm that updates model-estimates by counting over belief values. We experiment with the performance of these algorithms under both fully and partially observable settings, and whether teacher forcing is used (via target recurrence) or not (as in output recurrence). Different methods of adapting the learning rate are explored, including RMSProp, linear decay, and maintaining individual learning rates for each transition filter, or filter-wise decay, as presented in Table I.

The BP RCNN’s loss function is defined in terms of the non-stationary beliefs at any given time instant. An online training approach is hence rather than batch mode. We observe the filter-wise decay outperforms linear decay when different actions are chosen with varying frequencies. RMSProp suffers from the oscillations in the loss function that arise due to this dynamic nature, and hence performs poorly. The use of teacher forcing mitigates this dynamic nature over time, increasing replanning accuracy from $21.11\%$ to $95.62\%$. The $95.62\%$ replanning accuracy attained under partial-observability approaches the $96.88\%$ accuracy of the algorithm under fully observable settings.

QMDP RCNN: For the QMDP RCNN, the objective is learn a reward function that results in a similar policy and level of performance as the original reward. Since learning such a reward such that the demonstrated trajectories are optimal does not have a unique solution, quantifying the accuracy of the reward estimate is meaningless. Rather, we present the replanning accuracy (as used in the BP RCNN) for both learnt and known transition models and rewards. We also run policy evaluation on the generated policy using the original rewards, and present the increase in expected reward for the learnt models; defined as $\frac{1}{N_{d}^{2}}\sum_{s}\frac{V(s)_{learnt}-V(s)_{orig}}{V(s)_{orig}}$ . The results are presented in Table II.

As is the case in the BP RCNN, RMSProp (and adaptive learning rates in general) counter the magnitude of reward updates dictated by the QMDP RCNN, and hence adversely affect performance. Experience Replay marginally increases the replanning accuracy, but has a significant effect on the increase in expected reward. Similarly, using delayed feedback (after passes through an entire trajectory) also boosts the increase in expected reward. On learning both rewards and transition models, the QMDP RCNN achieves an appreciable $65.120\%$ policy error and a minimal $-10.688\%$ change in expected reward. We emphasize that given access solely to observations and action choices of the agent, and without assuming any feature engineering of the reward, the QMDP RCNN is able to achieve near-optimal levels of expected reward. Utilizing the ground truth transition with the learnt reward, the QMDP RCNN performs marginally worse, with a $63.476\%$ accuracy and a $-11.429\%$ change in expected reward.

The true efficacy of the BP RCNN and the QMDP RCNN lie in their ability to learn accurate transition models and reward functions in partially observable settings, where they outperforms existing model-based approaches of naive and weighted counting by significant margins, in terms of replanning accuracy, transition errors, and expected reward. Finally, we note that while all $3$ defined RCNN architectures are demonstrated for 2-D cases, these architectures can be extended to any number of dimensions, and number of actions, with suitable modifications to the convolution operation in higher dimensions.

VI Conclusion

In this paper, we defined $3$ RCNN like architectures, namely the Value Iteration RCNN, the Belief Propagation RCNN, and the QMDP RCNN, to facilitate a more natural representation of solutions to model-based Reinforcement Learning. Together, these contributions speed up the planning process in a partially observable environment, reducing the cost of replanning for model-based approaches. Given access to agent observations and action choices over time, the BP RCNN learns the transition model, and the QMDP RCNN learns the reward function, and subsequently replans with learnt models to make near-optimal action choices. The proposed architectures were also found to outperform existing model-based approaches in speed and model accuracy. The natural symbiotic representation of planning and learning algorithms allows these approaches to be extended to more complex tasks, by integrating them with sophisticated perception modules.