L EARNING P ROGRAMMATICALLY S TRUCTURED R EPRESENTATIONS WITH P ERCEPTOR G RADIENTS
A BSTRACT
We present the perceptor gradients algorithm – a novel approach to learning symbolic representations based on the idea of decomposing an agent’s policy into i) a perceptor network extracting symbols from raw observation data and ii) a task encoding program which maps the input symbols to output actions.
We show that the proposed algorithm is able to learn representations that can be directly fed into a Linear-Quadratic Regulator (LQR) or a general purpose A* planner.
Our experimental results conﬁrm that the perceptor gradients algorithm is able to efﬁciently learn transferable symbolic representations as well as generate new observations according to a semantically meaningful speciﬁcation
I NTRODUCTION
Learning representations that are useful for devising autonomous agent policies to act, from raw data, remains a major challenge.
Despite the long history of work in this area, fully satisfactory solutions are yet to be found for situations where the representation is required to address symbols whose speciﬁc meaning might be crucial for subsequent planning and control policies to be effective.
So, on the one hand, purely data-driven neural network based models, e.g., (Duan et al., 2016;
Arulkumaran et al., 2017), make signiﬁcant data demands and also tend to overﬁt to the observed data distribution (Srivastava et al., 2014).
On the other hand, symbolic methods that offer powerful abstraction capabilities, e.g., (Kansky et al., 2017; Verma et al., 2018), are not yet able to learn from raw noisy data.
Bridging this gap between neural and symbolic approaches is an area of active research (Garnelo et al., 2016; Garcez et al., 2018; Kser et al., 2017; Penkov & Ramamoorthy, 2017).
In many applications of interest, the agent is able to obtain a coarse ‘sketch’ of the solution quite independently of the detailed representations required to execute control actions.
For instance, a human user might be able to provide a programmatic task description in terms of abstract symbols much easier than more detailed labelling of large corpora of data.
In the literature, this idea is known as end-user programming (Lieberman et al., 2006), programming by demonstration (Billard et al., 2008) or program synthesis (Gulwani et al., 2017).
In this space, we explore the speciﬁc hypothesis that a programmatic task description provides inductive bias that enables signiﬁcantly more efﬁcient learning of symbolic representations from raw data.
The symbolic representation carries semantic content that can be grounded to objects, relations or, in general, any pattern of interest in the environment.
We address this problem by introducing the perceptor gradients algorithm which decomposes a typical policy, mapping from observations to actions, into i) a perceptor network that maps observations to symbolic representations and ii) a user-provided task encoding program which is executed on the perceived symbols in order to generate an action.
We consider both feedforward and autoencoding perceptors and view the program as a regulariser on the latent space which not only provides a strong inductive bias structuring the latent space, but also attaches a semantic meaning to the learnt representations.
We show that the perceptor network can be trained using the REINFROCE estimator (Williams, 1992) for any task encoding program.
We apply the perceptor gradients algorithm to the problem of balancing a cart-pole system with a
Linear-Quadratic Regulator (LQR) from pixel observations, showing that the state variables over which a concise control law could be deﬁned is learned from data.
Then, we demonstrate the use of the algorithm in a navigation and search task in a Minecraft-like environment, working with a 2.5D rendering of the world, showing that symbols for use within a generic A* planner can be learned.
We demonstrate that the proposed algorithm is not only able to efﬁciently learn transferable symbolic representations, but also enables the generation of new observations according to a semantically meaningful speciﬁcation.
We examine the learnt representations and show that programmatic regularisation is a general technique for imposing an inductive bias on the learning procedure with capabilities beyond the statistical constraints typically used.
R ELATED W ORK
Representation learning approaches rely predominantly on imposing statistical constraints on the latent space (Bengio et al., 2013) such as minimising predictability (Schmidhuber, 1992), maximising independence (Barlow et al., 1989; Higgins et al., 2017), minimising total correlation (Chen et al., 2018;
Kim & Mnih, 2018) or imposing structured priors on the latent space (Chen et al., 2016;
Narayanaswamy et al., 2017).
While learning disentangled features is an important problem, it does not by itself produce features of direct relevance to the planning/control task at hand.
For example, the ‘best’ features describing a dynamic system may be naturally entangled, as in a set of differential equations.
A programmatic task representation allows such dependencies to be expressed, making subsequent learning more efﬁcient and improving generalisation capabilities (Kansky et al., 2017;
Kusner et al., 2017; Gaunt et al., 2017; Verma et al., 2018).
Indeed, the idea of leveraging domain knowledge and imposing model driven constraints on the latent space, has been studied in different domains.
Much of this work is focused on learning representations for predicting and controlling physical systems where various assumptions about the underlying dynamic model are made (Watter et al., 2015; Iten et al., 2018; Fraccaro et al., 2017;
Karl et al., 2017).
Bezenac et al.
(2018) even leverage a theoretical ﬂuid transport model to forecasting sea surface temperature.
Model based representation learning approaches have also been applied to inverse graphics, where a visual renderer guides the learning process (Mansinghka et al., 2013;
Kulkarni et al., 2014; Ellis et al., 2018), and inverse physics, where a physics simulator is utilised (Wu et al., 2017).
Interestingly, Kulkarni et al.
(2015) propose a renderer that takes a programmatic description of the scene as input, similar to the one used in Ellis et al.
Of particular relevance to our work is the idea of learning compositional visual concepts by enforcing the support of set theoretic operations such as union and intersection in the latent space (Higgins et al., 2018).
Programmatic regularisation, which we propose, can be viewed as a general tool for expressing such model based constraints.
Programmatic task descriptions can be obtained through natural language instructions (Kaplan et al., 2017; Matuszek et al., 2013), demonstrations in virtual environments (Penkov & Ramamoorthy, 2017) or even manually speciﬁed.
Importantly, problems that appear quite hard from a pixel-level view can actually be more easily solved by constructing simple programs which utilise symbols that exploit the structure of the given problem.
Sometimes, utilising prior knowledge in this way has been avoided in a puristic approach to representation and policy learning.
In this paper, we address the more pragmatic view wherein the use of coarse task descriptions enables the autonomous agents to efﬁciently learn more abstract representations with semantic content that are relevant to practice.
P ROBLEM D EFINITION
Let us consider the Markov decision process (MDP) represented as the tuple ( S , A , P, r, γ, P 0 ) where S is the set of possible states, A is the set of possible actions, P is the state transition probability distribution, r : S ×
A → R is the reward function, γ is the reward discounting factor and Pis the probability distribution over the initial states.
At each time step t , the agent observes a state s t ∈ S and chooses an action a t ∈
A which results in a certain reward r t .
We consider the stochastic policy π θ ( a t | s t ) belonging to a family of functions parameterised by θ such that π θ : S → P A ( A ) where P A is a probability measure over the set A .
We are interested in decomposing the policy π θ into i) a perceptor ψ θ : S → P Σ (Σ) , where Σ is a set of task related symbols and P Σ is a probability measure over it, and ii) a task encoding program
ρ : Σ → A such that ρ ◦ ψ θ : S →
A as shown in Figure 1.
In this paper, we address the problem of learning ψ θ with any program ρ and investigate the properties of the learnt set of symbols Σ .
M ETHOD
Starting from an initial state of the environment s 0 ∼ P 0 ( s ) and following the policy π θ for T time steps results in a trace τ
= ( s 0 , a 0 , s 1 , a 1 , . . .
, s T , a T ) of T + 1 state-action pairs and T reward values ( r 1 , r 2 , . . .
, r T ) where r t = r
( s t , a t ) .
The standard reinforcement learning objective is to ﬁnd an optimal policy π ∗ θ by searching over the parameter space, such that the total expected return
[Equation]
is maximised, where R t ( τ ) = (cid:80)
Ti = t γ i − t r ( s t , a t ) is the return value of state s t .
The REINFORCE estimator (Williams, 1992) approximates the gradient of the cost as
[Equation]
where n is the number of observed traces, b φ is a baseline function paramterised by φ introduced to reduce the variance of the estimator.
Let us now consider the following factorisation of the policy
[Equation]
where σ t ∈ Σ are the symbols extracted from the state s t by the perceptor ψ θ , resulting in the augmented trace
τ =
( s 0 , σ 0 , a 0 , s 1 , σ 1 , a 1 , . .
, s T , σ T , a T ) .
We are interested in exploiting the programmatic structure supported by the symbols σ t and so we set
[Equation]
which is a Dirac delta distribution centered on the output of the task encoding program ρ ( σ t ) for the input symbols σ t .
Even though the program should produce a single action, it could internally work with distributions and simply sample its output.
Decomposing the policy into a program and a perceptor enables the description of programmatically structured policies, while being able to learn the required symbolic representation from data.
In order to learn the parameters of the perceptor ψ θ , we prove the following theorem.
Theorem 1 (Perceptor Gradients) .
For any decomposition of a policy π θ into a program ρ and a perceptor ψ θ such that
[Equation]
the gradient of the log-likelihood of a trace sample τ ( i ) obtained by following π θ is
[Equation]
Proof.
Substituting π θ ( a t | s t ) according to (5) gives
[Equation]
Theorem 1 has an important consequence – no matter what program ρ we choose, as long as it outputs an action in a ﬁnite amount of time, the parameters θ of the perceptor ψ θ can be learnt with the standard REINFORCE estimator.
Feedforward Perceptor
By combining theorem 1 with (2)
[Equation]
we derive the following loss function
[Equation] [Equation]
and τ ( i ) =
( s 0 , σ 0 , s 1 , σ 1 , . .
, s T , σ T ) contains T + 1 sampled state-symbol pairs.
Algorithmdemonstrates how to rollout a policy decomposed into a perceptor and a program in order to obtain trajectory samples τ ( i ) , while the overall perceptor gradients learning procedure is summarised in
Algorithm 2.
Autoencoding Perceptor
The perceptor is a mapping such that ψ θ : S → P Σ (Σ) and so by learning the inverse mapping
ω υ : Σ → P S ( S ) , parameterised by υ , we enable the generation of states (observations) from a structured symbolic description.
Thus ψ θ and ω υ form an autoencoder, where the latent space is Σ .
Importantly, the resulting autoencoder can be trained efﬁciently by applying the reparameterisation trick (Kingma & Welling, 2014; Jang et al., 2016) when sampling values for σ t during the perceptor rollout and reusing the obtained samples for the training of the generator ω υ .
In order to do so, we simply augment the loss in (7) with a reconstruction loss term
[Equation]
E XPERIMENTAL R ESULTS 5. C ART -P OLE B ALANCING
We ﬁrst consider the problem of balancing a cart-pole system by learning symbolic representations from the raw image observations.
The cart-pole system is well studied in optimal control theory and it is typically balanced with an LQR (Zhou et al., 1996).
We exploit this knowledge and set the program ρ to implement an LQR.
The perceptor ψ θ is a convolutional neural network (see A.1) as shown in the overall experiment diagram in Figure 2.
We deﬁne the state vector as
[Equation]
(11) where x ∈ R is the linear position of the cart and α ∈ R is the angle of the pendulum with respect to its vertical position as shown in Figure 2.
Input: ψ θ , ρ
Output: τ , r 1: T for t = 0 to T do s t ← observe environment σ t ← sample from ψ θ ( σ | s t ) a t ← ρ ( σ t ) r t ← execute a t append ( s t , σ t ) to τ
( θ, φ ) ← Initialise parameters repeatfor i = 1 to n do τ ( i ) , r ( i ) 1: T ← rollout ( ψ θ , ρ ) for t = 0 to T do
R ( i ) t ← (cid:80)
Ti
= t γ i − t r ( i ) t
A ( i ) t ← (cid:16) R ( i ) t − b φ ( s ( i ) t ) (cid:17)
L ψ ← 1 n (cid:80) ni =1 (cid:80) T − 1 t =0 log ψ θ ( σ ( i ) t | s ( i ) t )
A ( i ) t
L b ← 1 n (cid:80) ni =1 (cid:80) T − 1 t =0 (cid:16) R
( i ) t − b φ ( s ( i ) t ) (cid:17)
L ← L ψ + L b g ← ∇ θ, φ L ( θ, φ ) ( θ, φ ) ← Update parameters using g until convergence of parameters ( θ, φ ) ;
LQR Program Given the standard state space representation of a cart-pole system (see A.3) we can design a feedback control law u
= − Kσ , where u corresponds to the force applied to the cart and K is a gain matrix.
In an LQR design, the gain matrix K is found by minimising the quadratic cost function
[Equation]
where we set Q = 10 3 I 4 and R = 1 as proposed in (Lam, 2004).
We set the program ρ to be
[Equation]
otherwise
[Equation]
13) producing 2 discrete actions required by the
OpenAI gym cart-pole environment.
We used the python-control 1 package to estimate
K =
[ − 1 − 2 .
25 − 30 .
74 − 7 . 07] .
5.1. L EARNING P ERFORMANCE
In this experimental setup the perceptor is able to learn from raw image observations the symbolic representations required by the LQR controller.
The average reward obtained during training is shown in Figure 3.
We compare the performance of the perceptor gradients algorithm to a standard policy gradients algorithm, where we have replaced the program with a single linear layer with sigmoid activation.
The perceptor obtains an average reward close to the maximum of 199 approximately after 3000 iterations compared to 7000 iterations for the standard policy, however the obtained reward has greater variance.
Intuitively this can be explained with the fact that the program encodes a signiﬁcant amount of knowledge about the task which speeds up the learning, but also deﬁnes a much more constrained manifold for the latent space that is harder to be followed during stochastic gradient descent.
5.1. P ERCEPTOR L ATENT S PACE
The state space for which the minimum of the LQR cost in (12) is obtained is deﬁned only up to scale and rotation (see A.4).
Therefore, we use one episode of labelled data to ﬁnd the underlying linear transformation through constrained optimisation.
The transformed output of the perceptor for an entire episode is shown in Figure 4.
The position and angle representations learnt by the perceptor match very closely the ground truth.
However, both the linear and angular velocities do not match the true values and the associated variance is also quite large.
Investigating the results, we found out that the LQR controller is able to balance the system even if the velocities are not taken into account.
Given that the performance of the task is not sensitive to the velocity estimates, the perceptor was not able to ground the velocities from the symbolic state representation to the corresponding patterns in the observed images.
We compared the representations learnt by the perceptor to the ones learnt by a β VAE (Higgins et al., 2017).
In order to do so, we generated a dataset of observations obtained by controlling the cart-pole with the perceptor for 100 episodes.
We set the β VAE encoder to be architecturally the same as the perceptor and replaced the convolutional layers with transposed convolutions for the decoder.
We performed linear regression between the latent space of the trained β VAE and the ground truth values.
As it can be seen from the results in Figure 4 the representations learnt by the β VAE do capture some of the symbolic state structure, however they are considerably less precise than the ones learnt by the perceptor.
The β VAE does not manage to extract the velocities either and also collapses the distribution resulting in high certainty of the wrong estimates.
As proposed by Higgins et al.
(2017), setting β > 1 encourages the β VAE to learn disentangled representations.
The results shown in Figure 4, though, were obtained with β = 0 .
1 , otherwise the regularisation on the latent space forcing the latent dimensions to be independent was too strong.
It has been recognised by the community that there are better ways to enforce disentanglement such as minimising total correlation (Chen et al., 2018; Kim & Mnih, 2018).
However, these methods also rely on the independence assumption which in our case does not hold.
The position and the angle of the cart-pole system are clearly entangled and the program is able to correctly bias the learning procedure as it captures the underlying dependencies.
5. M INECRAFT : G O TO P OSE
Task Description We apply the perceptor gradients algorithm to the problem of navigating to a certain pose in the environment by learning symbolic representations from images.
In particular, we consider a 5 × 5 grid world where an agent is to navigate from its location to a randomly chosen goal pose.
The agent receives +1 reward if it gets closer to the selected goal pose, +5 if it reaches the position and +5 if it rotates to the right orientation.
To encourage optimal paths, the agent also receives -0.5 reward at every timestep.
A symbolic representation of the task together with the 2.5D rendering of the environment and the autoencoding perceptor, which we train (see A.2), are shown in Figure 5.
We express the state of the environment as
[Equation]
[Equation] where x, y ∈ { 1 , 2 , 3 , 4 , 5 } are categorical variables representing the position of the agent in the world and α ∈ { 1 , 2 , 3 , 4 } represents its orientation.
A* Program Given that the pose of the agent σ and the goal pose G are known this problem can be easily solved using a general purpose planner.
Therefore, in this experiment the program ρ implements a general purpose A* planner.
In comparison to the simple control law program we used in the cart-pole experiments, ρ in this case is a much more complex program as it contains several loops, multiple conditional statements as well as a priority queue.
For the experiments in this section we directly plugged in the implementation provided by the python-astar package 2 .
At every timestep, a path is found between the current σ t produced by the perceptor and the goal
G randomly chosen at the beginning of the episode such that the agent either moves to one of theneighbouring squares or rotates in-place at 90 ◦ , 180 ◦ or 270 ◦ .
The output action a t = ρ ( σ t ) is set to the ﬁrst action in the path found by the A* planner.
5.2. L EARNING P ERFORMANCE
In this experimental setup the perceptor is able to learn the symbolic representations required by the
A* planner from raw image observations.
The average reward obtained during training is shown in Figure 6.
Again, we compare the performance of the perceptor gradients to a standard policy gradients algorithm, where we have replaced the program with a single linear layer with softmax output.
Additionally, we rendered an arrow in the observed images to represent the chosen goal such that the policy network has access to this information as well.
In only 2000 iterations, the perceptor obtains an average reward close to the optimal one of approximately 11 .
35 , while it takes more than 30000 iterations for the policy gradients algorithm to approach an average reward of 10.
Furthermore, given the highly structured nature of the environment and the task, the perceptor gradients agent eventually learns to solve the task with much greater reliability than the pure policy gradients one.
See A.5 for experimental results on the Minecraft tasks with a feedforward perceptor instead of an autoencoding one.
5.2. P ERCEPTOR L ATENT S PACE
In this case the latent space directly maps to the symbolic state description of the environment and so we collected a dataset of 1000 episodes and compared the output of the perceptor to the ground truth values.
The results, summarised in the confusion matrices in Figure 7, indicate that the perceptor has learnt to correctly ground the symbolic state description to the observed data.
Despite the fact that there are some errors, especially for the orientation, the agent still learnt to perform the task reliably.
This is the case because individual errors at a certain timestep have a limited impact on the eventual solution of the task due to the robust nature of the abstractions supported by the symbolic
A* planner.
5.2. G ENERATING O BSERVATIONS
Since we have trained an autoencoding perceptor we are also able to generate new observations, in this case images of the environment.
Typically, manual inspection of the latent space is needed in order to assign each dimension to a meaningful quantity such as position or orientation.
However, this is not the case for autoencoding perceptors, as the program attaches a semantic meaning to each of the symbols it consumes as an input.
Therefore, we can generate observations according to a semantically meaningful symbolic speciﬁcation without any inspection of the latent space.
In
Figure 8, we have chosen a sequence of symbolic state descriptions, forming a trajectory, that we have passed through the decoder in order to generate the corresponding images.
Given the lack of noise in the rendering process we are able to reconstruct images from their symbolic descriptions almost perfectly.
Nevertheless, some minor orientation related artefacts can be seen in the generated image corresponding to t = 5 .
5. M INECRAFT : C OLLECT W OOD
Task Description
The last task we consider is navigating to and picking up an item, in particular a block of wood, from the environment.
In addition to the motion actions, the agent can now also pick up an item if it is directly in front of it.
The pick action succeeds with 50% chance, thus, introducing stochasticity in the task.
As discussed by Levesque (2005), this problem cannot be solved with a ﬁxed length plan and requires a loop in order to guarantee successful completion of the task.
The agent receives +5 reward whenever it picks up a block of wood.
We expand the state to include the location of the wood block resulting in
[Equation]
where x w , y w ∈ { 1 , 2 , 3 , 4 , 5 } are categorical variables representing the location of the block of wood and x , y , and α are deﬁned as before.
The symbolic state representation as well as the rendered observations are shown in Figure 9.
Stacked Perceptors
In the cart-pole experiment the controller balances the system around a ﬁxed state, whereas in the navigation experiment the A* planner takes the agent to a randomly chosen, but known, goal pose.
Learning to recognise both the pose of the agent and the position of the item is an ill posed problem since there is not a ﬁxed frame of reference – the same sequence of actions can be successfully applied to the same relative conﬁguration of the initial state and the goal, which can appear anywhere in the environment.
We have, however, already trained a perceptor to recognise the pose of the agent in the ’go to pose’ task and so in this experiment we demonstrate how it can be transferred to a new task.
We combine the pose perceptor from the previous experiment with another perceptor that is to learn to recognise the position of the wood block.
Given the symbolic output of both perceptors, we can simply concatenate their outputs and feed them directly into the
A* program, as shown in Figure 9.
Even though the symbols of the pose perceptor are directly transferable to the current task, it needs to be adapted to the presence of the unseen before wooden block.
We train both perceptors jointly, but keep the learning rate for the pre-trained pose perceptor considerably lower than the one for the wood perceptor.
This ensures that no catastrophic forgetting occurs during the initial stages of training.
5.3. L EARNING P ERFORMANCE
As shown in Figure 10 the agent is quickly able to solve the task with the stacked conﬁguration of perceptors.
It signiﬁcantly outperforms the neural network policy that is trained on the entire problem and achieves optimal performance in less than 3000 iterations.
These result clearly demonstrate that the symbolic representations learnt by a perceptor can be transferred to new tasks.
Furthermore, perceptors not only can be reused, but also adapted to the new task in a lifelong learning fashion, which is reminiscent of the ﬁndings in (Gaunt et al., 2017) and their idea of neural libraries.
5.3. G ENERATING O BSERVATIONS
Stacking perceptors preserves the symbolic nature of the latent space and so we are again able to generate observations from semantically meaningful speciﬁcations.
In Figure 11 we have shown a set of generated state samples from a symbolic speciﬁcation over the joint latent space.
The samples not only look realistic, but also take occlusions into account correctly (e.g. see top left sample).
C ONCLUSION
In this paper we introduced the perceptor gradients algorithm for learning programmatically structured representations.
This is achieved by combining a perceptor neural network with a task encoding program.
Our approach achieves faster learning rates compared to methods based solely on neural networks and yields transferable task related symbolic representations which also carry semantic content.
Our results clearly demonstrate that programmatic regularisation is a general technique for structured representation learning.
A S UPPLEMENTARY I NFORMATION A. C ART -P OLE F EEDFORWARD P ERCEPTOR
The input of the cart-pole feedforward perceptor is a stack of 4 consecutive grayscale 32 ×images that we render the cart-pole system onto as shown in Figure 2.
This is a setup similar to the one proposed in (Mnih et al., 2015) which preserves temporary information in the input such that it can be processed by a convolutional neural network.
The architecture of the perceptor ψ θ is shown in Figure 12.
Note that the perceptor shares its convolutional layers with the baseline network b φ .
The outputs of the perceptor are the mean and the diagonal covariance matrix of a 4-dimensional normal distribution.
A. M INECRAFT ’G O - TO P OSE ’ A UTOENCODING P ERCEPTOR
For this experiment we designed an autoencoding perceptor, the architecture of which is shown in
Figure 13.
The input is a single color image containing 2.5D rendering of the world as shown in
[Figure]
[Equation] [Figure] [Equation]
[Figure]
The state vector of the cart-pole system is
[Equation]
where x ∈ R is the linear position of the cart and α ∈ R is the angle of the pendulum with respect to its vertical position as shown in Figure 2.
By following the derivation in (Lam, 2004) of the linearised state space model of the system around the unstable equilibrium [0 0 0 0]
T (we ignore the modelling of the gearbox and the motor)
we set the system matrix A and input matrix B to
[Equation]
[Equation]
) where m is the mass of the pole, M is the mass of the pole and the cart, l is half of the pendulum length, g is the gravitational acceleration, L is set to I
+ ml 2 ml
and I = ml
2 12 is the moment of inertia of the pendulum.
We use the cart-pole system from OpenAI gym where all the parameters are pre-speciﬁed and set to m = 0 .
1 , M = 1 . 0 and l = 0 .
A. LQR S TATE S PACE U NIQUENESS
Given that Q is a matrix of the form λ I 4 where λ is a scalar, then any rotation matrix M applied on the latent vector σ will have no impact on the cost in (12) as
[Equation]
since rotation matrices are orthogonal.
Additionally, scaling σ only scales the cost function and so will not shift the locations of the optima.
A. M INECRAFT T ASKS WITH A F EEDFORWARD P ERCEPTOR
In order to study the contribution of the decoder to the performance of the agent in the Minecraft tasks we conducted a set of ablation experiments where we replaced the autoencoding perceptor with a feedforward one.
Figure 14 and Figure 15 show the learning performance at the ’go-to pose’ and ’collect-wood’ tasks, respectively, with a feedforward perceptor.
Overall, the results indicate that the main effect of the decoder is to decrease the variance of the obtained reward during training.
The feedforward perceptor manages to ground the position of the agent slightly more accurately than the autoencoding perceptor, however the accuracy of the orientation has decreased.
The reason for this is that orientation has little effect on the performance of the agent as it can move to any square around it, regardless of its heading.
This is similar to the cart-pole task where the linear and angular velocities had little effect on the LQR performance.