Deep Predictive Policy Training using Reinforcement Learning

Deep Predictive Policy Training using Reinforcement Learning

Ali Ghadirzadeh, Atsuto Maki, Danica Kragic and Mårten Björkman Authors are with the Robotics, Perception and Learning Lab (RPL), CSC, KTH Royal Institute of Technology, Stockholm, Sweden. algh|atsuto|dani|

Skilled robot task learning is best implemented by predictive action policies due to the inherent latency of sensorimotor processes. However, training such predictive policies is challenging as it involves finding a trajectory of motor activations for the full duration of the action. We propose a data-efficient deep predictive policy training (DPPT) framework with a deep neural network policy architecture which maps an image observation to a sequence of motor activations. The architecture consists of three sub-networks referred to as the perception, policy and behavior super-layers. The perception and behavior super-layers force an abstraction of visual and motor data trained with synthetic and simulated training samples, respectively. The policy super-layer is a small sub-network with fewer parameters that maps data in-between the abstracted manifolds. It is trained for each task using methods for policy search reinforcement learning. We demonstrate the suitability of the proposed architecture and learning framework by training predictive policies for skilled object grasping and ball throwing on a PR2 robot. The effectiveness of the method is illustrated by the fact that these tasks are trained using only about 180 real robot attempts with qualitative terminal rewards.

I Introduction

We humans are skilled in a majority of our basic physical activities such as opening a door or grasping an object, and also demonstrate impressive motor learning abilities to acquire new skills e.g., learning to play a new sport. On the other hand, most robotic systems demonstrate behaviors far from being considered skilled, especially in unstructured environments. The gap between humans and robots in motor skill learning may be explained not only by the highly versatile sensing and actuating capabilities of humans, but also by the way the sensorimotor process is intertwined.

Studies in motor learning of biological systems reveal that skilled action performance is likely to be the result of predictive types of controllers, i.e., an uninterrupted motor activation executed for a given observation snapshot [1]. This differs from the reactive types of controllers which produces motor activation in response to every sensory input and inherently slows down the process by at least the sensor delays. Task execution for basic physical activities may thus be unnecessarily slow on robotic systems operating with reactive controllers. This can be improved by adapting predictive action policies to the robotic systems with an efficient motor learning process.

Fig. 1: The experimental setup for the ball throwing task (a), and four snapshots demonstrating a successful throw towards a target object (b-e). The ball is highlighted with red circles to improve the visibility.

In this work, we present a framework based on reinforcement (see [2, 3] for surveys) and use-dependent learning [1] to train a deep neural network policy, mapping uncalibrated image observations to long trajectories of low-level motor commands for a robotic manipulator. The main contributions are: 1) a robot learning framework to acquire skilled behaviors, 2) a neural network architecture for data-efficient deep policy learning consisting of three super-layers (see Fig. 3): two for abstraction of visual data and motor trajectories and one for mapping data in-between the abstracted manifolds, and 3) a mechanism that enables learning a behavior in simulation and exploiting it on a real robot. The framework is applied on a PR2 robot to learn two skilled behaviors, ball throwing and object grasping, as shown in Fig. 1 and Fig. 2.

We demonstrate experimentally that the network architecture enables training of complex behaviors with qualitative terminal rewards, rewards provided at the end of trajectories, evaluating whole sequences with qualitative measures such as ”good” or ”excellent”. This reward type is less informative, but it is often more realistic in practice, especially for training predictive policies, due to the difficulties of evaluating every single time-step action and the latency of the reward system. Furthermore, providing qualitative rewards require less engineering efforts and can be done by a non-expert operator during a training phase.

This paper is organized as follows: In the rest of this section, we provide a short background, as well as review earlier work related to the presented. Sec. II introduces two structures to abstract motor and image data. The learning framework as well as the architecture is presented in Sec. III. Experimental results are provided in Sec. IV, testing one simulated task and two real robotic tasks. Finally, Sec. V will conclude our discussions and suggest future work.

I-a Background

In general, a deep action policy consists of a mechanism to extract informative states from raw sensor data, and another mechanism to generate motor activations (or sequences of activations, in the case of predictive policies) for each state.

Given its richness as a sensory modality, vision plays an important role in providing information about the environment and the state of the system. However, visual data may contain more information than can be processed efficiently by an agent that learns a motor behavior. Therefore, due to processing limitations, the agent needs to filter out data redundant to the motor learning task. This phenomenon is known as inattentional blindness in psychological studies [4]. Traditionally in robotics, filtering unnecessary information to extract a task-relevant state representation is done using hand-crafted features (e.g., [5]). However, in recent years a considerable amount of research is devoted to learning state representations from raw observation data (e.g., [6, 7, 8, 9, 10, 11]). This improves autonomy of motor task learning. Furthermore, simultaneously training perception and action policy may result in an overall better policy, compared to hand-crafted perception models [12].

The other mechanism is required to learn to control motor activations to perform a task. Studies in neuroscience [1] distinguish between three types of motor learning processes in biological systems: 1) error-based learning, 2) reinforcement learning, and 3) use-dependent learning. Error-based learning optimizes each motor activation in each time-step by updating it in the opposite direction of the error gradient (see e.g., [13, 14]). The error is generally found internally as the difference between the perceived sensory outcome to the desired or predicted one. Reinforcement learning (RL) improves the action selection policy by reinforcing those actions which are likely to yield higher rewards. The reward is given by the environment, including the robot itself and possibly an instructor. Finally, use-dependent learning is a learning process based on movement repetitions without a target. It facilitates policy training by modeling correlations in motor activations i.e., encoding kinematic details of different motions. This enables the other two processes to start training at a higher level abstraction of motor activations.

Fig. 2: The experimental setup for the grasp task (a), and four subsequent snapshots demonstrating a successful predictive object grasping (b-e).

I-B Related work

Fig. 3: The deep predictive policy architecture consisting of the perception, policy and behavior super-layers. A mean-centered RGB image is given as the network input. The perception super-layer abstracts the image data with a number of spatial positions corresponding to the task-related objects. The policy super-layer stochastically maps the abstracted state into a point in the action manifold. Finally, the behavior super-layer generates a long trajectory of motor commands for the given sampled action that is applied to the robot for consecutive time-steps.

In this section, we review related studies regarding 1) methods for extracting task-relevant state representation from raw sensory observations, and 2) methods for predictive action policy learning.

I-B1 State representation learning

Different methods have earlier been applied in robotics to infer a compact state representation from high-dimensional observations, in particular camera images, applicable to motor control learning tasks. The study conducted by Jodogne and Piater [15] is among earlier studies on task-specific state representation learning. Their method finds features that distinguish a finite set of classes based on which the agent makes action decisions. However, their method may not be directly applicable to many real robotic problems, as discretizing of sensory observations into a finite number of classes is not always possible. In a more recent study, Jonschkowski and Brock [8] proposed learning a task-relevant state representation based on prior physical knowledge. Although being a promising concept, their approach has so far only been validated on a toy example and may not be data-efficient enough to be applied on real robotic problems.

Training a low-dimensional state representation in an autoencoder structure (refer to Sec. II) has gained popularity in recent years [6, 7, 8, 9, 10, 11]. Lange et al. [7] trained a deep convolutional autoencoder to learn a state space representation to autonomously control a toy race car. They devised a transformation based on expert knowledge to shape the state manifold for the control task. In similar work, Wahlström et al. [10] used an autoencoder structure to find a state manifold based on which a multi-time-step prediction of camera images is feasible. For this purpose, they refined the cost function to include the reconstruction error for the current and the next time-step. Watter et al. [9] proposed a similar cost function to train a variational autoencoder (refer to Sec. II-2) with an extra constraint that state dynamics are to be linearizable w.r.t. all control signals. The same approach is also used by van Hoof et al. [11] to extract task-specific state representations for visual and tactile data. However, methods to augment specific types of dynamics simultaneously with state representation learning may be impractical in certain tasks, such as hitting a table-tennis ball, where semi-random motor actions sparsely result in sensible task-relevant outcomes during the initial training phase.

Alternatively, certain properties of the states’ dynamics can be ensured by limiting the autoencoder to a specific class of features e.g., spatial image features. Based on this idea, Finn et al. [6] proposed a deep spatial autoencoder for visuomotor tasks. They exploited the spatial softmax layer, introduced in their earlier work [12], to convert the activation of the last layer of the convolutional filters into spatial image positions. This topology has been applied in a number of real robotic visuomotor learning tasks [12, 16, 17, 18].

Beyond methods of finding a low-dimensional state representations suitable for action policy learning, there are other methods that can train perception and policy end-to-end, without a clear-cut boundary. The most well-known examples are the Deep Q-network (DQN) [19] and deep deterministic policy gradient (DDPG) [20] methods for discrete and continuous action spaces, respectively. In general, these methods are hardly applicable to robotics problems, since they require a large amount of agent-environment interaction data which may not be affordable with real robotic setups.

Another approach to train perception-policy end-to-end is the guided policy search (GPS) introduced by Levine et al. [12]. Guided policy search is a framework which converts policy search reinforcement learning into a supervised learning paradigm with the supervised data coming from a secondary trajectory optimizer such as iterative linear-Gaussian regulator (iLQG) [21]. GPS may be used in training a deep predictive policy; however it would require a secondary trajectory optimizer method with an engineered initial state representation.

In this work, we exploit spatial autoencoders introduced in [6] to learn a low-dimensional state representation. This is a reasonable choice, since task-relevant states can be learned in an autoencoder without requiring the robot to actively manipulate the environment. We improve the spatial autoencoder stability w.r.t. visual distractors by further training the convolutional layers to filter out these distractors.

I-B2 Predictive action policy learning

Predictive actions can be found using optimal control theory methods. These methods optimize a known cost function given a set of differential equations and constraints. The differential equations represent the dynamic model of the system, and the constraints determines limitations on the control signals and states. The methods in optimal control theory most resembling our approach are trajectory optimization [22] and model predictive control (MPC) [23].

Trajectory optimization methods find open-loop control trajectories by optimizing a given cost function for a given dynamic model. Similarly, MPC optimizes a cost function over a finite horizon. However, unlike trajectory optimization, MPC applies only the first action of the trajectory and repeats this procedure in every time-step. Our approach differs from optimal control theory in that ours is data-driven and is not dependent on a known dynamic model.

More recently, MPC is accompanied by general function approximators, such as Gaussian processes [24, 14] or artificial neural networks [10] to learn the dynamic model directly from interaction data to alleviate the need for an a-priori known dynamic model. However, learning a dynamic model from data may not always be feasible, especially in high-dimensional sensorimotor spaces, and the error, the difference between the true dynamics and the predicted ones, can be accumulated over the prediction horizon resulting in an incorrect control trajectory. Furthermore, MPC still reactively responds to each state perceived by the system and requires an expensive optimization in each time-step.

Another related approach is a biologically inspired method [1] to split a complex behavior into a set of basic motor primitives. These approaches, known as dynamic movement primitives (DMP), have found applications in robot learning by demonstration [25] and also reinforcement learning [26, 3]. They have been successfully applied to a number of robotic skilled behavior learning tasks, such as robot tennis swings [25], ball-in-a-cup and underactuated swing-up [26], dart throwing and table tennis [27].

Our method relates to DMP in that both methods find a representation of motor trajectories to train high-level behaviors. However, in our case, each point in a 5D action-manifold, passed through a fully-connected neural network, characterizes a motion trajectory for all the robot joints, while in the DMP case, the motion of each joint is characterized by a set of differential equations with a number of trainable parameters. Our method compared to DMP makes a more abstract representation while being computationally less expensive.

Ii Representation learning

In order to train the deep policy in a data-efficient manner, the mapping from high-dimensional observations to motor trajectories is done in a low-dimensional space by abstracting observation and motor data with and , where and are the abstracted state and action manifolds and the two functions, and , represent the perception and behavior super-layers as illustrated in Fig. 3. These super-layers are trained by two different structures, based on spatial [6] and variational [28] autoencoders, introduced later in this section.

An autoencoder is an hourglass-shaped artificial neural network which learns a low-dimensional representation of the training data at its bottleneck. It learns such representations by first mapping the input data into the low-dimensional manifold (encoder) and then reconstructing the input from the low-dimensional data at the network output (decoder). We train two autoencoder structures to find an abstract data representation for two purposes: 1) to efficiently extract task-relevant states from raw camera images through the perception super-layer, and 2) to infer motor signal data distributions for a skilled behavior to be able to produce samples as close as possible to the learned distribution. In following subsections, we introduce the two autoencoder structures used on our framework.

Ii-1 Convolutional spatial autoencoders [6]

This autoencoder encodes the input image with the 2D positions of a number of points belonging to the task-related objects of the scene. The input image is reconstructed based on this encoding i.e., based on the knowledge of where the relevant objects are located in the image. The encoding inherently preserves spatial distances in the input image and is therefore suitable for robotic manipulation tasks [6, 12, 16, 18].

The encoder of a convolutional spatial autoencoder consists of concatenations of several convolutional layers followed by a spatial soft arg-max. For a given input, each convolutional filter generates a 2D response map. The encoded features correspond to the response map of the last convolutional layer. These maps are first normalized and transformed into probability density functions based on the spatial softmax layer, as , where is the element of the response map and is a trainable temperature parameter. The encoded feature point is found as for each filter . Therefore, the size of the encoded feature space is twice the number of the filters in the last convolutional layer. The decoder part is a fully-connected neural network which reconstructs a down-sampled gray-scale version of the input image. Please refer to the original work [6] for a more detailed description.

Ii-2 Variational autoencoders [28]

A generative behavior model is trained to represent long motor trajectories with a low-dimensional action manifold. In this way, a motor task can be learned by searching for a policy in the action manifold instead of the high-dimensional motor trajectory space, making the search considerably more efficient. However, in order to benefit from policy search in the low-dimensional action manifold, we need to ensure the action data is encoded with a proper distribution. Variational autoencoders reproduce training data by sampling a latent variable (in our case the action ) from a prior distribution , typically an isotropic Gaussian [29, 28].

The key idea is to learn an encoder and decoder , where for an input , gives a distribution over with values that are likely to regenerate when applied to . The encoder outputs are typically assumed to be normal distributed, . In essence the encoder consists of two parts; a mean network and a variance network . To make distributed according to the prior distribution , the Kullback-Leibler divergence (KL-divergence) between and is defined as an extra loss function,


where it is assumed that the prior distribution is an isotropic Gaussian and represents the KL-divergence distance.

Iii Training a deep predictive policy

We describe our method to train the deep predictive policy architecture consisting of the perception, policy and behavior super-layers shown in Fig. 3. The input image is processed by the perception layers to output a number of spatial image points representing the image position of the task-relevant objects to form the state vector . The policy super-layer processes the state and produces a normal distribution from which the action is sampled. The sampled action is mapped to a predictive trajectory of time-step motor outputs by the behavior super-layer.

The perception and behavior layers are trained individually in two different autoencoder structures. The encoder network of the perception autoencoder and the decoder network of the behavior autoencoder are then used as the perception and behavior super-layers of the deep predictive policy, respectively. Finally, after the perception and behavior layers are set, the policy layers are trained based on RL policy search. It is important to emphasize that, given the abstraction of both perception and action, the input-output of the policy super-layer is typically low-dimensional and it is quite affordable to train the few parameters of this small sub-network with standard RL policy search. In the rest of this section, we provide details on how to train each of the super-layers to learn a skilled behavior.

Iii-a Perception super-layer

The perception model is trained by the spatial autoencoder [6] introduced in Sec. II-1. As shown in Fig. 3, the perception model processes a mean-centered RGB image with a concatenation of four convolutional layers followed by a spatial soft arg-max. There are image coordinates corresponding to the 8 filters of the last convolutional layer.

The decoder network consists of two fully-connected hidden-layers with 500 and 2000 neurons, respectively. The decoder output layer formed by 3600 neurons to reconstruct the gray-scaled version of the input image with pixels. Following the original work, we added an extra cost to penalize the variability of learned features for consecutive training data, when images come in sequence.

Fig. 4: Generating a synthetic image database to train the perception autoencoder. A sample synthetic image input (a), and the corresponding target image (b).

The perception layer encodes the task-relevant object position with 8 image points. For the experiments in Sec. IV we used the Pikachu toy shown in Fig. 4 as target. A database of 50 images was generated with the Pikachu in different places over the table. A synthetic database containing 5400 images was created by randomly displacing the Pikachu within few pixels and also overlaying a number of distractors at random positions, as shown in Fig. 4a. The autoencoder is trained to discard the irrelevant distractors by only reconstructing the task-specific object (Fig. 4b). This is similar to the idea of denoising autoencoders but instead of adding noise to the input image, different visual distractors are superimposed at random image positions. In this way, the convolutional filters are trained to discard the distractors while giving a maximum activation for the task-specific object.

Iii-B Behavior super-layer

As shown in Fig. 3, the behavior super-layer is a generative model which maps a point from the action-manifold into a motor trajectory consisting of time-steps for the joints. A valid motion trajectory of a robotic manipulator consists of highly correlated motor outputs to realize a specific behavior. The correlation is due to the smoothness of the end-effector motion in task space which is governed by the kinematic structure of the robot and the low dynamics of the motor system. Therefore it is natural to assume that the motor outputs follows a specific distribution which is unknown a-priori. It is the purpose of the variational autoencoder described in Sec. II-2 to capture this distribution given past motor activations.

The encoder of the variational autoencoder transforms input trajectories into a normal distribution in a space using a neural structure with three layers of 1000, 500 and 250 hidden units for both the mean and variance networks, and , that constitute the encoder. The two first layers are shared between the networks. A sample is drawn according to the encoded mean and variance and is mapped by the decoder to a complete trajectory. The decoder, that will represent the behavior super-layer, has three hidden layers similar to the encoder, but in reverse order.

Trajectory data to train the variational autoencoder may not necessarily come from the real robot. In our experiments, we produced the training data in a simulated environment. Although the simulated robot does not behave exactly like the real robot, it is assumed that the action manifolds in simulation and on the real robot are related by a transformation, a transformation that will be captured by the policy super-layer that is yet to be learned. This claim agrees with our experimental results presented in Sec. IV.

A blind action policy is required to generate simulated motor trajectories, based on which the autoencoder is trained. A blind policy is a controller which randomly generates action trajectories irrespective of state. We devised such controllers for each task by demonstrating several motion samples to the robot and deriving a general model which produces similar motions. The use of blind controllers is also common in other studies e.g., [6] to capture initial training data. Here, we only apply the blind controller on the simulated robot. We trained two behavior models corresponding to the throwing and grasping behaviors with 10000 motor trajectory samples gathered with the Gazebo simulator shown in Fig. 5.

Fig. 5: Three consecutive snapshots showing a successful predictive reaching task in Gazebo simulator (a-c).

Iii-C Policy super-layer

A predictive action policy learning task can be represented as a MDP problem. The goal is to maximize the expected reward over trajectories , with being the observation at time and the motor outputs predictively determined for time-steps. A trajectory reward is given at the end of each episode as a discrete or a continuous value. The predictive policy determines the probability distribution over time-step motor commands given the observation at time , . The distribution of trajectories can thus be written as . The goal is to find the policy parameters such that the likelihood of trajectories with higher terminal rewards increases.

As discussed in Sec. II, instead of training a deep policy in the high-dimensional sensorimotor space, we train a low-dimensional policy in the state-action manifold. Algorithm 1 summarizes how to train this low-dimensional policy. The perception and behavior super-layers are trained separately with synthetic and simulated data as discussed in Sec. III-A and Sec. III-B, prior to policy training. The policy super-layer is initialized such that for any input state, the output is distributed as . For each episode, an input image observation is captured and encoded to the state manifold with the perception super-layer. Given the input state, the policy generates a distribution over the action manifold from which a sample is drawn. The sampled action is then mapped to the corresponding motor trajectory through the generative behavior super-layer. The motor commands are applied on the robot for time-steps and the reward is received at the end of each episode. The policy is trained with the training data collected after number of episodes to maximize the expected reward .

We evaluated RL policy search including vanilla policy gradient (VPG), relative entropy policy search (REPS), cross entropy method (CEM) (see [3, 2] for surveys) and trust region policy optimization (TRPO) [30] for the simulated task (refer to the Sec. IV-B). Based on the observed convergence rates achieved in the simulations, we chose TRPO to train the policies for the real-robot tasks.

Input : Trained perception and behavior super-layers
Output : Trained policy super-layer
Initialize policy with ;
for each iteration do
       for each episode do
             Input an image observation ;
             Sample ;
             Run on the robot;
             Input episode reward ;
             Record the triple ;
      Train the policy with the recorded triples;
Algorithm 1 Training the policy super-layer.

Iv Experiments

We devised three different experiments to evaluate the suitability of the proposed learning framework to train deep predictive policies for skilled behaviors. In the first experiment, a simulated PR2 robot learns how to predictively move the end-effector towards different points on a planar surface. The other two experiments are performed on the real PR2 robot shown in Fig. 1 and Fig. 2. In these experiments, we exploit the proposed framework to train the deep policy architecture to realize two skilled behaviors; ball throwing and object grasping. Although the object grasping task is a well-established problem in robotics, what is referred to here is a skilled behavior learning problem, which requires training a deep neural network policy to generate a trajectory of motor activations predictively from a single image observation snapshot. The ball throwing task is also another instantiation of skilled behaviors which involves learning a complex sequence of motor activations for a given image observation. In the following, we first introduce the experimental setup (A) and then present results from experiments on the simulated (B) and the real robot tasks (C).

Iv-a Experimental setup

All the experiments are performed on the PR2’s left arm which is a 7-DOF manipulator. Each joint of the arm is controlled by a velocity PID controller which translates joint velocity commands (rad/s) to motor torques. The velocity commands are predictively generated by the deep predictive policy and are sent to the low-level controllers at 10 Hz. An external camera is mounted on top of the robot head. The camera direction is controlled by the head pan and tilt joints to view the table in front of the robot (see e.g., Fig. 1). From an RGB camera image resolution of pixels, images are first cropped to pixels and then down-scaled and mean-centered to pixels. We use Caffe [31] to train both the perception and behavior autoencoders and RLLAB [32] with default parameters for implementations of VPG, REPS, TRPO and CEM methods. The video and data for this work are available for download from the first author’s homepage

Iv-B Simulated reaching task

In a first experiment, a simulated PR2 robot learns to generate sequences of motor commands predictively to move its end-effector towards every point on a planar surface. Fig. 5 demonstrates a successful trial to reach to the point indicated by the red circle. The network in this case consists of the policy and behavior super-layers. It receives a 2D target position on the surface as an input and generates the motor trajectory to reach that target point. The behavior super-layer is pre-trained as explained in Sec. III-B and it is fixed during the entire experiment. There are two behavior models realized for the two different tasks, grasping and ball throwing. The reaching task utilizes the same behavior model as the grasping task. Both models are trained in the Gazebo simulator environment as shown in Fig. 5. The trained behavior super-layers are used for the simulation and the real robotic tasks without any further modifications.

Fig. 6: The average reward for different training iterations with continuous (left) and discrete (right) reward types for the simulated reaching task.

The policy super-layer is trained with the reward signal received at the end of each episode. We evaluated both continuous and discrete reward values to train the policy layers. For the simulated reaching task, the continuous reward is calculated as , where is the final 2D position of the end-effector, and is the target. The discrete reward is simply found by discretizing the continuous reward to values and .

We evaluated TRPO, REPS, CEM and VPG when used for training the policy super-layer of the reaching task. The super-layer was trained with each method for three independent trials consisting of 15 iterations. Each iteration includes 25 reaching attempts. Fig. 6 demonstrates the average reward for each iteration, for both the continuous and discrete reward types. It asserts that TRPO achieves the fastest learning rate compared to the rest of methods. According to the figure, VPG and REPS demonstrate similar performance, with VPG slightly better than REPS, whereas CEM exhibits unstable performance. Table I demonstrates the performance of the corresponding deterministic policies found after training for 15 iterations. The deterministic policy is found by considering the mean value of the stochastic policy. The table evaluates the deterministic policies for target points that already exist in the training set, as well as for novel targets.

Training targets Novel targets
continuous discrete continuous discrete
TRPO 0.57 0.50 0.55 0.50
REPS 0.01 0.00 -0.01 0.00
VPG 0.03 0.04 0.02 0.02
CEM -1.12 -0.24 -1.3 -0.26
TABLE I: Evaluation of the deterministic reaching policies for training and novel target points.

As shown in this experiment, TRPO is the most suitable method to train the policy super-layer as it demonstrates the fastest learning rate. Furthermore, we conclude that the introduced behavior model would facilitate learning complex motor activations, requiring a reasonable number of trials with the only information provided in terms of discrete terminal rewards. The experiment also shows that the trained action manifold renders efficient policy learning with a small sub-network possible.

Fig. 7: Training progress for the real robot tasks

Iv-C Real robot tasks

We trained the proposed architecture to realize the two skilled behaviors, grasping and ball throwing, on the PR2 robot. The full network maps raw image observations to a predictive sequence of motor velocity commands through the three super-layers shown in Fig. 3.

The perception and behavior super-layers are pre-trained as explained in Sec. III-A and Sec. III-B and are kept fixed during the experiments. The perception model is shared for both tasks, while the behavior models are different. The behavior model for the grasping task is the same as the one used in the previous section for the simulated reaching task.

As TRPO yielded the best performance in the simulations, it is used for the training policy super-layer for the real robot tasks. TRPO trains the grasping policy with continuous rewards similar to the reaching task, with the difference that a successful grasp will get a reward of +2. The distance to a target is measured based on the forward kinematic model of the robot. For the ball throwing task, we only have access to qualitative reward values such as the ball hit the object (+2), landed closely (+1) or far (-1) to/from the object.

Fig. 7 illustrates the training progress for both tasks. Each task is trained for 15 iterations, with 12 action attempts each. Therefore, a total of 180 attempts are generated for each task which roughly correspond to one hour of data collection. The figure demonstrates the reward outcome for the stochastic policy i.e., randomly sampling the action according to the learned action distribution. Similarly to the previous section, we also evaluated the deterministic version of the policy and reported the results in Table II. The table demonstrates the average reward over 12 different attempts with the deterministic policies for cases when there are no visual distractors, with known distractors available during perception model training, and unknown distractors never seen before.

No distractors Known Unknown
Ball-throwing 1.58 1.58 0.83
Grasping 1.13 1.11 0.61
TABLE II: Evaluation of deterministic policies for the two real robot tasks, for cases with no distractors, known and unknown distractors respectively.

As mentioned earlier, the maximum reward is +2 which corresponds to a perfect action execution for both tasks. Also, +1 means the task was performed nearly as well i.e., the ball landed close to the object (throwing task), or the gripper touched the object (grasping task). As shown in Table II, for the case with no distractors, both trained networks receive rewards on average greater than 1.0. For ball throwing the average reward is suggesting most throws hit the object. For cases with distractors seen during perception model learning, the results are close to cases with no distractors. However, with unknown distractors the performance is drastically reduced, suggesting that the perception model is not robust against previously unseen objects.

Fig. 8: Spatial feature points extracted by the perception model, for the objects observed during the training (left), and the test objects (right).

Fig. 8 illustrates feature points generated by the perception model for both known and unknown distractors. As it is shown for the unknown case, some features are wrongly clustered around the distractor objects. This would result in wrong action generation and failure in the tasks. Given the limited set of training images used to train the perception model though, it is reasonable to assume that robustness can be improved with more images.

V Conclusions and future work

We have presented a deep predictive policy architecture with a data-efficient learning framework and evaluated it by learning skilled object grasping and ball throwing tasks on a PR2 robot. The architecture consists of three sub-networks referred to as perception, policy and behavior super-layers. Data-efficiency is achieved by training the perception and behavior super-layers with synthetic and simulated data, while only the few parameters of the policy super-layer need to be trained using real robot data. We experimentally demonstrated that such a neural network policy can be trained efficiently to acquire complex behaviors, such as throwing a ball and hitting a target object, with only 180 real robot training trials. Furthermore, we showed that the network architecture enables training of these behaviors with only qualitative terminal rewards. This is an important feature that enables a task to be trained by non-expert operators.

We believe the proposed network architecture would gain in robustness by improving the perception model to more efficiently discard visual distractors. In future work, we will review different network structures with the goal of implementing a more robust perception model. We will also study transferability of features extracted at different layers of the model to extend the network to manipulate multiple target objects without necessarily re-training from scratch.

Also as a part of our future studies, we intend to modify the way the behavior super-layer training samples are gathered. Currently, a blind controller generates these motor samples. However, devising such controllers makes the system dependent on expert knowledge. To alleviate dependencies on experts, we will extend the learning framework to train the behavior super-layer with samples generated from an initial reactive controller, direct human demonstrations or motion capture systems.


This work was supported by the EU through the project socSMCs (H2020-FETPROACT-2014) and the Swedish Research Council.


  • [1] D. M. Wolpert, J. Diedrichsen, and J. R. Flanagan, “Principles of sensorimotor learning,” Nature Reviews Neuroscience, vol. 12, no. 12, pp. 739–751, 2011.
  • [2] J. Kober, J. A. Bagnell, and J. Peters, “Reinforcement learning in robotics: A survey,” The International Journal of Robotics Research, vol. 32, no. 11, pp. 1238–1274, 2013.
  • [3] M. P. Deisenroth, G. Neumann, J. Peters et al., “A survey on policy search for robotics,” Foundations and Trends in Robotics, vol. 2, no. 1–2, pp. 1–142, 2013.
  • [4] S. B. Most, B. J. Scholl, E. R. Clifford, and D. J. Simons, “What you see is what you set: sustained inattentional blindness and the capture of awareness.” Psychological review, vol. 112, no. 1, p. 217, 2005.
  • [5] A. Ghadirzadeh, J. Bütepage, A. Maki, D. Kragic, and M. Björkman, “A sensorimotor reinforcement learning framework for physical human-robot interaction,” in IROS, 2016.
  • [6] C. Finn, X. Y. Tan, Y. Duan, T. Darrell, S. Levine, and P. Abbeel, “Deep spatial autoencoders for visuomotor learning,” in ICRA, 2016.
  • [7] S. Lange, M. Riedmiller, and A. Voigtlander, “Autonomous reinforcement learning on raw visual input data in a real world application,” in IJCNN, 2012.
  • [8] R. Jonschkowski and O. Brock, “State representation learning in robotics: Using prior knowledge about physical interaction,” in RSS, 2014.
  • [9] M. Watter, J. Springenberg, J. Boedecker, and M. Riedmiller, “Embed to control: A locally linear latent dynamics model for control from raw images,” in NIPS, 2015.
  • [10] N. Wahlström, T. B. Schön, and M. P. Deisenroth, “Learning deep dynamical models from image pixels,” IFAC-PapersOnLine, vol. 48, no. 28, pp. 1059–1064, 2015.
  • [11] H. van Hoof, N. Chen, M. Karl, P. van der Smagt, and J. Peters, “Stable reinforcement learning with autoencoders for tactile and visual data,” in IROS, 2016.
  • [12] S. Levine, C. Finn, T. Darrell, and P. Abbeel, “End-to-end training of deep visuomotor policies,” Journal of Machine Learning Research, vol. 17, no. 39, pp. 1–40, 2016.
  • [13] A. Ghadirzadeh, A. Maki, and M. Björkman, “A sensorimotor approach for self-learning of hand-eye coordination,” in IROS, 2015.
  • [14] A. Ghadirzadeh, J. Bütepage, D. Kragic, and M. Björkman, “Self-learning and adaptation in a sensorimotor framework,” in ICRA, 2016.
  • [15] S. Jodogne and J. H. Piater, “Closed-loop learning of visual control policies,” Journal of Artificial Intelligence Research, vol. 28, pp. 349–391, 2007.
  • [16] Y. Chebotar, M. Kalakrishnan, A. Yahya, A. Li, S. Schaal, and S. Levine, “Path integral guided policy search,” arXiv preprint arXiv:1610.00529.
  • [17] P. Agrawal, A. Nair, P. Abbeel, J. Malik, and S. Levine, “Learning to poke by poking: Experiential learning of intuitive physics,” in NIPS, 2016.
  • [18] A. Yahya, A. Li, M. Kalakrishnan, Y. Chebotar, and S. Levine, “Collective robot reinforcement learning with distributed asynchronous guided policy search,” arXiv preprint arXiv:1610.00673.
  • [19] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski et al., “Human-level control through deep reinforcement learning,” Nature, vol. 518, no. 7540, pp. 529–533, 2015.
  • [20] T. P. Lillicrap, J. J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra, “Continuous control with deep reinforcement learning,” arXiv preprint arXiv:1509.02971, 2015.
  • [21] S. Levine and P. Abbeel, “Learning neural network policies with guided policy search under unknown dynamics,” in NIPS, 2014.
  • [22] J. T. Betts, Practical methods for optimal control and estimation using nonlinear programming.   SIAM, 2010.
  • [23] E. F. Camacho and C. B. Alba, Model predictive control.   Springer Science & Business Media, 2013.
  • [24] J. Kocijan, R. Murray-Smith, C. E. Rasmussen, and A. Girard, “Gaussian process model based predictive control,” in ACC, 2004.
  • [25] A. J. Ijspeert, J. Nakanishi, and S. Schaal, “Learning attractor landscapes for learning motor primitives,” NIPS, 2003.
  • [26] J. Kober and J. R. Peters, “Policy search for motor primitives in robotics,” in NIPS, 2009.
  • [27] J. Kober, E. Oztop, and J. Peters, “Reinforcement learning to adjust robot movements to new situations,” in RSS, 2010.
  • [28] D. P. Kingma and M. Welling, “Auto-encoding variational Bayes,” in ICLR, 2014.
  • [29] C. Doersch, “Tutorial on variational autoencoders,” arXiv preprint arXiv:1606.05908, 2016.
  • [30] J. Schulman, S. Levine, P. Abbeel, M. I. Jordan, and P. Moritz, “Trust region policy optimization.” in ICML, 2015, pp. 1889–1897.
  • [31] Y. Jia, E. Shelhamer, J. Donahue, S. Karayev, J. Long, R. Girshick, S. Guadarrama, and T. Darrell, “Caffe: Convolutional architecture for fast feature embedding,” arXiv preprint arXiv:1408.5093, 2014.
  • [32] Y. Duan, X. Chen, R. Houthooft, J. Schulman, and P. Abbeel, “Benchmarking deep reinforcement learning for continuous control,” in ICML, 2016.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description