Hardware Conditioned Policies for Multi-Robot Transfer Learning

Hardware Conditioned Policies for Multi-Robot Transfer Learning

Tao Chen
The Robotics Institute
Carnegie Mellon University
Pittsburgh, PA 15213
taoc1@cs.cmu.edu
&Adithyavairavan Murali
The Robotics Institute
Carnegie Mellon University
Pittsburgh, PA 15213
amurali@cs.cmu.edu
&Abhinav Gupta
The Robotics Institute
Carnegie Mellon University
Pittsburgh, PA 15213
abhinavg@cs.cmu.edu
Abstract

Deep reinforcement learning could be used to learn dexterous robotic policies but it is challenging to transfer them to new robots with vastly different hardware properties. It is also prohibitively expensive to learn a new policy from scratch for each robot hardware due to the high sample complexity of modern state-of-the-art algorithms. We propose a novel approach called Hardware Conditioned Policies where we train a universal policy conditioned on a vector representation of robot hardware. We considered robots in simulation with varied dynamics, kinematic structure, kinematic lengths and degrees-of-freedom. First, we use the kinematic structure directly as the hardware encoding and show great zero-shot transfer to completely novel robots not seen during training. For robots with lower zero-shot success rate, we also demonstrate that fine-tuning the policy network is significantly more sample-efficient than training a model from scratch. In tasks where knowing the agent dynamics is important for success, we learn an embedding for robot hardware and show that policies conditioned on the encoding of hardware tend to generalize and transfer well. Videos of experiments are available at: https://sites.google.com/view/robot-transfer-hcp.

 

Hardware Conditioned Policies for Multi-Robot Transfer Learning


  Tao Chen The Robotics Institute Carnegie Mellon University Pittsburgh, PA 15213 taoc1@cs.cmu.edu Adithyavairavan Murali The Robotics Institute Carnegie Mellon University Pittsburgh, PA 15213 amurali@cs.cmu.edu Abhinav Gupta The Robotics Institute Carnegie Mellon University Pittsburgh, PA 15213 abhinavg@cs.cmu.edu

\@float

noticebox[b]32nd Conference on Neural Information Processing Systems (NIPS 2018), Montréal, Canada.\end@float

1 Introduction

In recent years, we have seen remarkable success in the field of deep reinforcement learning (DRL). From learning policies for games Mnih et al. [2015], Silver et al. [2016] to training robots in simulators Lillicrap et al. [2015], neural network based policies have shown remarkable success. But will these successes translate to real world robots? Can we use DRL for learning policies of how to open a bottle, grasping or even simpler tasks like fixturing and peg-insertion? One major shortcoming of current approaches is that they are not sample-efficient. We need millions of training examples to learn policies for even simple actions. Another major bottleneck is that these policies are specific to the hardware on which training is performed. If we apply a policy trained on one robot to a different robot it will fail to generalize. Therefore, in this paradigm, one would need to collect millions of examples for each task and each robot.

But what makes this problem even more frustrating is that since there is no standardization in terms of hardware, different labs collect large-scale data using different hardware. These hardware vary in degrees of freedom (DOF), kinematic design and even dynamics. Because the learning process is so hardware-specific, there is no way to pool and use all the shared data collected across using different types of robots, especially when the robots are trained under torque control. There have been efforts to overcome dependence on hardware properties by learning invariance to robot dynamics using dynamic randomization [Peng et al., 2017]. However, learning a policy invariant to other hardware properties such as degrees of freedom and kinematic structure is a challenging problem.

In this paper, we propose an alternative solution: instead of trying to learn the invariance to hardware; we embrace these differences and propose to learn a policy conditioned on the hardware properties itself. Our core idea is to formulate the policy as a function of current state and the hardware properties . So, in our formulation, the policy decides the action based on current state and its own capabilities (as defined by hardware vector). But how do you represent the robot hardware as vector? In this paper, we propose two different possibilities. First, we propose an explicit representation where the kinematic structure itself is fed as input to the policy function. But such an approach will not be able to encode robot dynamics which might be hard to measure. Therefore, our second solution is to learn an embedding space for robot hardware itself. Our results indicate that encoding the kinematic structures explicitly enables high success rate on zero-shot transfer to new kinematic structure. And learning the embedding vector for hardware implicitly without using kinematics and dynamics information is able to give comparable performance to the model where we use all of the kinematics and dynamics information. Finally, we also demonstrate that the learned policy can also adapt to new robots with much less data samples via finetuning.

2 Related Work

Transfer in Robot Learning Transfer learning has a lot of practical value in robotics, given that it is computationally expensive to collect data on real robot hardware and that many reinforcement learning algorithms have high sample complexity. Taylor et al. present an extensive survey of different transfer learning work in reinforcement learning [Taylor and Stone, 2009]. Prior work has broadly focused on the transfer of policies between tasks [Devin et al., 2017, Fu et al., 2016, Pinto and Gupta, 2017, Rusu et al., 2016], control parameters [Murali et al., 2018], dynamics [Peng et al., 2017, Aravind et al., 2017, Nilim and El Ghaoui, 2005, Mandlekar et al., 2017], visual inputs [Tobin et al., 2017], non-stationary environments [Al-Shedivat et al., 2017], goal targets [Schaul et al., 2015]. Nilim et. al. presented theoretical results on the performance of transfer under conditions with bounded disturbances in the dynamics [Nilim and El Ghaoui, 2005]. There have been efforts in applying domain adaption such as learning common invariant feature spaces between domains [Gupta et al., 2017] and learning a mapping from target to source domain [Bocsi et al., 2013]. Such approaches require prior knowledge and data from the target domain. A lot of recent work has focused on transferring policies trained in simulation to a real robot [Peng et al., 2017, Tobin et al., 2017, Barrett et al., 2010, Mahler et al., 2017]. However, there has been very limited work on transferring knowledge and skills between different robots [Devin et al., 2017, Helwa and Schoellig, 2017]. The most relevant paper is Devin et al. [Devin et al., 2017], who propose module networks for transfer learning and used it to transfer 2D planar policies across hand-designed robots. The key idea is to decompose policy network into robot-specific module and task-specific module. In our work, a universal policy is conditioned on a vector representation of the robot hardware - the policy does not necessarily need to be completely retrained for a new robot. There has also been some concurrent work in applying graph neural networks (GNN) as the policy class in continuous control [Wang et al., 2018, Sanchez-Gonzalez et al., 2018]. [Wang et al., 2018] uses a GNN instead of a MLP to train a policy. [Sanchez-Gonzalez et al., 2018] uses a GNN to learn a forward prediction model for future states and performs model predictive control on agents. Our work is orthogonal to these methods as we condition the policy on the augmented state of the robot hardware, which is independant of the policy class.

Robust Control and Adaptive Control Robust control can be considered from several vantage points. In the context of trajectory optimization methods, model predictive control (MPC) is a popular framework which continuously resolves an open-loop optimization problem, resulting in a closed loop algorithm that is robust to dynamics disturbances. In the context of deep reinforcement learning, prior work has explored trajectory planning with an ensemble of dynamics models Mordatch et al. [2015], adversarial disturbances Mandlekar et al. [2017], training with random dynamics parameters in simulation Peng et al. [2017], Aravind et al. [2017], etc. [Peng et al., 2017] uses randomization over dynamics so that the policy network can generalize over a large range of dynamics variations for both the robot and the environment. However, it uses position control where robot dynamics has little direct impact on control. We use low-level torque control which is severely affected by robot dynamics and show transfer even between kinematically different agents. There have been similar works in the area of adaptive control [Slotine and Weiping, 1988] as well, where unknown dynamics parameters are estimated online and adaptive controllers adapt the control parameters by tracking motion error. Our work is a model-free method which does not make assumptions like linear system dynamics. We also show transfer results on robots with different DOFs and joint displacements.

System Identification System identification is a necessary process in robotics to find unknown physical parameters or to address model inconsistency during training and execution. For control systems based on analytic models, as is common in the legged locomotion community, physical parameters such as the moment of inertia or friction have to be estimated for each custom robotic hardware Park et al. [2010], Nagarajan et al. [2009]. Another form of system identification involves the learning of a dynamics model for use in model-based reinforcement learning. Several prior research work have iterated between building a dynamics model and policy optimization Abbeel et al. [2006], Levine et al. [2016], Kahn et al. [2017]. In the context of model-free RL, Yu et al. proposed an Online System Identification [Yu et al., 2017] module that is trained to predict physical environmental factors such as the agent mass, friction of the floor, etc. which are then fed into the policy along with the agent state Yu et al. [2017]. However, results were shown for simple simulated domains and even then it required a lot of samples to learn an accurate regression function of the environmental factors. There is also concurrent work which uses graph networks [Sanchez-Gonzalez et al., 2018] to learn a forward prediction model for future states and to perform model predictive control. Our method is model-free and only requires a simple hardware augmentation as input regardless of the policy class or DRL algorithms.

3 Preliminaries

We consider the multi-robot transfer learning problem under the reinforcement learning framework and deal with fully observable environments that are modeled as continuous space Markov Decision Processes (MDP). The MDPs are represented by the tuple , where is a set of continuous states, is a set of continuous actions, is the transition probability distribution, is the reward function, is the initial state distribution, and is the discount factor. The aim is to find a policy that maximizes the expected return.

There are two classes of approaches used for optimization: on-policy and off-policy. On-policy approaches (e.g., Proximal Policy Optimization (PPO) [Schulman et al., 2017]) optimize the same policy that is used to make decisions during exploration. On the other hand, off-policy approaches allow policy optimization on data obtained by a behavior policy different from the policy being optimized. Deep deterministic policy gradient (DDPG) [Lillicrap et al., 2015] is a model-free actor-critic off-policy algorithm which uses deterministic action policy and is applicable to continuous action spaces.

One common issue with training these approaches is sparse rewards. Hindsight experience replay (HER) [Andrychowicz et al., 2017] was proposed to improve the learning under the sparse reward setting for off-policy algorithms. The key insight of HER is that even though the agent has not succeeded at reaching the specified goal, the agent could have at least achieved a different one. So HER pretends that the agent was asked to achieve the goal it ended up with in that episode at the first place, instead of the one that we set out to achieve originally. By repeating the goal substitution process, the agent eventually learns how to achieve the goals we specified.

4 Hardware Conditioned Policies

Our proposed method, Hardware Conditioned Policies (HCP), takes robot hardware information into account in order to generalize the policy network over robots with different kinematics and dynamics. The main idea is to construct a vector representation of each robot hardware that can guide the policy network to make decisions based on the hardware characteristics. Therefore, the learned policy network should learn to act in the environment, conditioned on both the state and . There are several factors that encompass robot hardware that we have considered in our framework - robot kinematics (degree of freedom, kinematic structure such as relative joint positions and orientations, and link length), robot dynamics (joint damping, friction, armature, and link mass) - and other aspects such as shape geometry, actuation design, etc. that we will explore in future work. It is also noteworthy that the robot kinematics is typically available for any newly designed robot, for instance through the Universal Robot Description Format-URDF urd []. Nonetheless, the dynamics are typically not available and may be inaccurate or change over time even if provided. We now explain two ways on how to encode the robot hardware via vector .

4.1 Explicit Encoding

First, we propose to represent robot hardware information via an explicit encoding method (HCP-E). In explicit encoding, we directly use the kinematic structure as input to the policy function. Note that while estimating the kinematic structure is feasible, it is not feasible to measure dynamics. However, some environments and tasks might not be heavily dependent on robot dynamics and in those scenarios explicit encoding (HCP-E) might be simple and more practical than implicit embedding111We will elaborate such environments on section 5.1. We also experimentally show the effect of dynamics for transferring policies in such environments in Appendix C.1 and C.2.. We followed the popular URDF convention in ROS to frame our explicit encoding and incorporate the least amount of information to fully define a multi-DOF robot for the explicit encoding. It is difficult to completely define a robot with just its end-effector information, as the kinematic structure (even for the same DOF) affects the robot behaviour. For instance, the whole kinematic chain is important when there are obstacles in the work space and the policy has to learn to avoid collisions with its links.

Figure 1: Local coordinate systems for two consecutive joints

We consider manipulators composed of revolute joints (). Figure 1 shows two consecutive joints on the two ends of an L-shape link and their corresponding local coordinate systems with origin and with origin where -axis is the direction of revolute joint axis. To represent spatial relationship between , one needs to know the relative pose222If the manipulators only differ in length of all links, can be simply the vector of each link’s length. When the kinematic structure and DOF also vary, composed of link length is not enough. between and .

Relative pose can be decomposed into relative position and orientation. Relative position is represented by the difference vector between and , i.e., and . The relative rotation matrix from to is , where is the rotation matrix of relative to the world coordinate system. One can further convert rotation matrix which has elements into Euler rotation vector with only independent elements. Therefore, relative rotation can be represented by an Euler rotation vector . The relative pose is then , where denotes concatenation.

With relative pose of consecutive joints in hand, the encoding vector to represent the robot can be explicitly constructed as follows333 is relative pose from to . If , , . If , ,V. If , , .:

4.2 Implicit Encoding

In the above section, we discussed how kinematic structure of the hardware can be explicitly encoded as . However, in most cases, we need to not only encode kinematic structure but also the underlying dynamic factors. In such scenarios, explicit encoding is not possible since one cannot measure friction or damping in motors so easily. In this section, we discuss how we can learn an embedding space for robot hardware while simultaneously learning the action policies. Our goal is to estimate for each robot hardware such that when a policy function is used to take actions it maximizes the expected return. For each robot hardware, we initialize randomly. We also randomly initialize the parameters of the policy network. We then use standard policy optimization algorithms to update network parameters via back-propagation. However, since is also a learned parameter, the gradients flow back all the way to the encoding vector and update via gradient descent: , where is the cost function, is the learning rate. Intuitively, HPC-I trains the policy such that it not only learns a mapping from states to actions that maximizes the expected return, but also finds a good representation for the robot hardware simultaneously.

4.3 Algorithm

The hardware representation vector can be incorporated into many deep reinforcement learning algorithms by augmenting states to be: . We use PPO in environments with dense reward and DDPG + HER in environments with sparse reward in this paper. During training, a robot will be randomly sampled in each episode from a pre-generated robot pool filled with a large number of robots with different kinematics and dynamics. Alg. 1 provides an overview of our algorithm. The detailed algorithms are summarized in Appendix A (Alg. 2 for on-policy and Alg. 3 for off-policy).

Initialize a RL algorithm e.g. PPO, DDPG, DDPG+HER
Initialize a robot pool of size with robots in different kinematics and dynamics
for episode = 1:M  do
     Sample a robot instance
     Sample an initial state
     Retrieve the robot hardware representation vector
     Run policy in the environment for timesteps
     Augment all states with : denotes concatenation
     for n=1:W do
         Optimize actor and critic networks with via minibatch gradient descent
         if  is to be learned (i.e. for implicit encoding, HCP-I) then
              update via gradient descent in the optimization step as well
         end if
     end for
end for
Algorithm 1 Hardware Conditioned Policies (HCP)

5 Experimental Evaluation

Our aim is to demonstrate the importance of conditioning the policy based on a hardware representation for transferring complicated policies between dissimilar robotic agents. We show performance gains on two diverse settings of manipulation and hopper.

5.1 Explicit Encoding

Robot Hardwares: We created a set of robot manipulators based on the Sawyer robot in MuJoCo [Todorov et al., 2012]. The basic robot types are shown in Figure 2. By permuting the chronology of revolute joints and ensuring the robot design is feasible, we designed types of robots (named as A, B,…, I) in which the first four are 5 DOF, the next four are 6 DOF, and the last one is 7 DOF, following the main feasible kinematic designs described in hardware design literature Huo et al. [2012]. Each of these 9 robots were further varied with different link lengths and dynamics.

Tasks: We consider reacher and peg insertion tasks to demonstrate the effectiveness of explicit encoded representation. In reacher, robot starts from a random initial pose and it needs to move the end effector to the random target position. In peg-insertion, a peg is attached to the robot gripper and the task is to insert the peg into the hole on the table. It’s considered a success only if the peg bottom goes inside the hole more than . Goals are described by the 3D target positions of end effector (reacher) or peg bottom (peg insertion).

(a) A: 5 DOF
(b) B: 5 DOF
(c) C: 5 DOF
(d) D: 5 DOF
(e) E: 6 DOF
(f) F: 6 DOF
(g) G: 6 DOF
(h) H: 6 DOF
(i) I: 7 DOF
Figure 2: Robots with different DOF and kinematics structures. The white rings represent joints. There are variants of 5 and 6 DOF robots due to the different placements of joints.

States and Actions: The states of both environments consist of the angles and velocities of all robot joints. Action is -dimensional torque control over () joints. Since we consider robots with different DOF in this paper, we use zero-padding for robots with joints to construct a fixed-length state vector for different robots. And the policy network always outputs -dimensional actions, but only the first elements are used as the control command.

Robot Representation: As mentioned in section 4.1, is explicitly constructed to represent the robot kinematic chain: . We use zero-padding for robots with joints to construct a fixed-length representation vector for different robots.

Rewards: We use binary sparse reward setting because sparse reward is more realistic in robotics applications. And we use DPPG+HER as the backbone training algorithm. The agent only gets reward if POI is within euclidean distance of the desired goal position. Otherwise, it gets reward. We use in all experiments. However, this kind of sparse reward setting encourages the agent to complete the task using as less time steps as possible to maximize the return in an episode, which encourages the agent to apply maximum torques on all the joints so that the agent can move fast. This is referred to as bang–bang control in control theory[Artstein, 1980]. Hence, we added action penalty on the reward.

More experiment details are shown in Appendix B.

5.1.1 Does HCP-E improve performance?

To show the importance of hardware information as input to the policy network, we experiment on learning robotic skills among robots with different dynamics (joint damping, friction, armature, link mass) and kinematics (link length, kinematic structure, DOF). The basic robot types are listed in Figure 2. We performed several leave-one-out experiments (train on robot types, leave robot type untouched) on these robot types. The sampling ranges for link length and dynamics parameters are shown in Table 2 in Appendix B.1.1. We compare our algorithm with vanilla DDPG+HER (trained with data pooled from all robots) to show the necessity of training a universal policy network conditioned on hardware characteristics. Figure 3 shows the learning curves444The learning curves are averaged over random seeds on 100 testing robots and shaded areas represent standard deviation. of training on robot types A-G and I. It clearly shows that our algorithm HCP-E outperforms the baseline. In fact, DDPG+HER without any hardware information is unable to learn a common policy across multiple robots as different robots will behave differently even if they execute the same action in the same state. More leave-one-out experiments are shown in Appendix C.4.

Figure 3: Learning curves for multi-DOF setup. Training robots contain Type A-G and Type I robots (four 5-DOF types, three 6-DOF types, one 7-DOF type). Each type has 140 variants with different dynamics and link lengths. The 100 testing robots used to generate the learning curves are from the same training robot types but with different link lengths and dynamics. (a): reacher task with random initial pose and target position. (b): peg insertion with fixed hole position. (c): peg insertion with hole position randomly sampled in a box region. Notice that the converged success rate in (c) is only about . This is because when we randomly generate the hole position, some robots cannot actually insert the peg into hole due to physical limit. Some hole positions are not inside the reachable space (workspace) of the robots. This is especially common in 5-DOF robots.

5.1.2 Is HCP-E capable of zero-shot transfer to unseen robot kinematic structure?

We now perform testing in the leave-one-out experiments. Specifically, we can test the zero-shot transfer ability of policy network on new type of robots. Table 1 shows the quantitative statistics about testing performance on new robot types that are different from training robot types. Each data555The success rate is represented by the mean and standard deviation in the table is obtained by running the model on 1000 unseen test robots (averaged over 10 trials, 100 robots per trial) of that robot type but with different link lengths and dynamics.

Exp. Tasks Training Robot Types Testing Robot Type Alg. Success rate ()
I Reacher (random goals) A-G + I H HCP-E
II DDPG+HER
III A-D + F-I E HCP-E
IV DDPG+HER
V Peg Insertion (fixed goal) A-G + I H HCP-E
VI DDPG+HER
VII A-D + F-I E HCP-E
VIII DDPG+HER
IX A-H I HCP-E
X DDPG+HER
XI Peg Insertion (random goals) A-G + I H HCP-E
XII DDPG+HER
XIII A-D + F-I E HCP-E
XIV DDPG+HER
XV A-H I HCP-E
XVI DDPG+HER
Table 1: Zero-shot testing performance on new robot type

From Table 1, it is clear that HCP-E still maintains high success rates when the policy is applied to new types of robots that have never been used in training, while DDPG+HER barely succeeds at controlling new types of robots at all. The difference between using robot types A-G+I and A-D+F-I (both have four -DOF types, three -DOF types, and one -DOF type) is that robot type H is harder for peg insertion task than robot type E due to its joint configuration (it removes joint ). As we can see from Exp. I and V, HCP-E got about zero-shot transfer success rate even if it’s applied on the hard robot type H. Exp. X and XVI show the model trained with only DOF and DOF being applied to -DOF robot type. We can see that it is able to get about success rate in peg insertion task with fixed goal666Since we are using direct torque control without gravity compensation, the trivial solution of transferring where the network can regard the -DOF robot as a -DOF robot by keeping one joint fixed doesn’t exist here..

Figure 4: Testing distance distribution on a real sawyer robot. A used the policy from Exp. I, B used the policy from Exp. II, C used the policy trained with the actual Sawyer CAD model in simulation with randomized dynamics.

Zero-shot transfer to a real Sawyer robot: We show results on the multi-goal reacher task, as peg insertion required additional lab setup. Though the control frequency on the real robot is not as stable as that in simulation, we still found a high zero-shot transfer rate. For quantitative evaluation, we ran three policies on the real robot with results averaged over 20 random goal positions. A used the policy from Exp. I (HCP-E), B used the policy from Exp. II (DDPG+HER) while C used the policy trained with actual Sawyer CAD model in simulation with just randomized dynamics. The distance from target for the 20-trials are summarized in Figure 4. Despite of the large reality gap777The reality gap is further exaggerated by the fact that we didn’t do any form of gravity compensation in the simulation but the real-robot tests used the gravity compensation to make tests safer. , HCP-E (BLUE) is able to reach the target positions with a high success rate () 888The HCP-E policy resulted in a motion that was jerky on the real Sawyer robot to reach the target positions. This was because we used sparse reward during training. This could be mitigated with better reward design to enforce smoothness.. DDPG+HER (RED) without hardware information was not even able to move the arm close to the desired position.

Fine-tuning the zero-shot policy: Table 1 also shows that Exp. XI and Exp. XV have relatively low zero-shot success rates on new type of robots. Exp. XI is trained on easier -DOF robots (E, F, G) and applied to a harder -DOF robot type (H). Exp. XV is trained only on -DOF and -DOF robots and applied to -DOF robots (I). The hole positions are randomly sampled in both experiments. Even though the success rates are low, HCP-E is actually able to move the peg bottom close to the hole in most testing robots, while DDPG+HER is much worse, as shown in Figure 4(a). We also fine-tune the model specifically on the new robot type for these two experiments, as shown in Figure 4(b) and Figure 4(c). It’s clear that even though zero-shot success rates are low, the model can quickly adapt to the new robot type with the pretrained model weights.

(a)
(b)
(c)
Figure 5: (a): Distribution (violin plots) of distance between the peg bottom at the end of episode and the desired position. The three horizontal lines in each violin plot stand for the lower extrema, median value, and the higher extrema. It clearly shows that HCP-E moves the pegs much closer to the hole than DDPG+HER. (b): The brown curve is the learning curve of training HCP-E on robot type H with different link lengths and dynamics in multi-goal setup from scratch. The pink curve is the learning curve of training HCP-E on same robots with pretrained model from Exp. XI. (c): Similar to (b), the training robots are robot type I (7 DOF) and the pretrained model is from Exp. XV. (b) and (c) show that applying the pretrained model that is trained on different robot types to a new robot type can accelerate the learning by a large margin.

5.2 Implicit Encoding

Environment HCP-E shows remarkable success on transferring manipulator tasks to different types of robots. However, in explicit encoding we only condition on the kinematics of the robot hardware. For unstable systems in robotics, such as in legged locomotion where there is a lot of frequent nonlinear contacts Mandlekar et al. [2017], it is crucial to consider robot dynamics as well. We propose to learn an implicit, latent encoding (HCP-I) for each robot without actually using any kinematics and dynamics information. We evaluate the effectiveness of HCP-I on the 2D hopper [Erez et al., 2012]. Hopper is an ideal environment as it is an unstable system with sophisticated second-order dynamics involving contact with the ground. We will demonstrate that adding implicitly learned robot representation can lead to comparable performance to the case where we know the ground-truth kinematics and dynamics. To create robots with different kinematics and dynamics, we varied the length and mass of each hopper link, damping, friction, armature of each joint, which are shown in Table 5 in Appendix B.

Performance We compare HCP-I with HCP-E, HCP-E+ground-truth dynamics, and vanilla PPO model without kinematics and dynamics information augmented to states. As shown in Figure 5(a), HCP-I outperforms the baseline (PPO) by a large margin. In fact, with the robot representation being automatically learned, we see that HCP-I achieves comparable performance to HCP-E+Dyn that uses both kinematics and dynamics information, which means the robot representation learns the kinematics and dynamics implicitly. Since dynamics plays a key role in the hopper performance which can be seen from the performance difference between HCP-E and HCP-E+Dyn, the implicit encoding method obtains much higher return than the explicit encoding method. This is because the implicit encoding method can automatically learn a good robot hardware representation and include the kinematics and dynamics information, while the explicit encoding method can only encode the kinematics information as dynamics information is generally unavailable.

(a)
(b)
(c)
Figure 6: (a): Learning curves using hoppers with different kinematics and dynamics in training. HCP-I is able to automatically learn a good robot representation such that the learning performance can be on par with HCP-E+Dyn where we use the ground-truth kinematics and dynamics values. And HCP-I has a much better performance than vanilla PPO. (b): If we use the pretrained HCP-I model (only reuse the hidden layers) from (a) on 100 new hoppers, HCP-I with pretrained weights learns much faster than training from scratch. (c): Embedding visualization. The colorbar shows the hopper torso mass value. We can see that the embedding is smooth as the color transition is smooth.

Transfer Learning on New Agents We now apply the learned HCP-I model as a pretrained model onto new robots. However, since for the new robot is unknown, we fine-tune the policy parameters and also estimate . As shown in Figure 5(b), HCP-I with pretrained weights learns much faster than HCP-I trained from scratch. While in the current version, we do not show explicit few-shot results, one can train a regression network to predict the trained based on the agent’s limited interaction with environment.

Embedding Smoothness We found the implicit encoding to be a smooth embedding space over the dynamics. For example, we only vary one parameter (the torso mass) and plot the resultant embedding vectors. Notice that we reduce the dimension of to since we only vary torso mass. Figure 5(c) shows a smooth transition over torso mass (the color bar represents torso mass value, 1000 hoppers with different torso mass), where robots with similar mass are clustered together.

6 Conclusion

We introduced a novel framework of Hardware Conditioned Policies for multi-robot transfer learning. To represent the hardware properties as a vector, we propose two methods depending on the task: explicit encoding (HCP-E) and implicit encoding (HCP-I). HCP-E works well when task policy does not heavily depend on agent dynamics. It has an obvious advantage that it is possible to transfer the policy network to new robots in a zero-shot fashion. Even when zero-shot transfer gives low success rate, we showed that HCP-E actually brings the agents very close to goals and is able to adapt to the new robots very quickly with finetuning. When the robot dynamics is so complicated that feeding dynamics information into policy network helps improve learning, the explicit encoding is not enough as it can only encode the kinematics information and dynamics information is usually challenging and sophisticated to acquire. To deal with such cases, we propose an implicit encoding scheme (HCP-I) to learn the hardware embedding representation automatically via back-propagation. We showed that HCP-I, without using any kinematics and dynamics information, can achieve good performance on par with the model that utilized both ground truth kinematics and dynamics information.

Acknowledgement

This research is partly sponsored by ONR MURI N000141612007 and the Army Research Office and was accomplished under Grant Number W911NF-18-1-0019. Abhinav was supported in part by Sloan Research Fellowship and Adithya was partly supported by a Uber Fellowship. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein. The authors would also like to thank Senthil Purushwalkam and Deepak Pathak for feedback on the early draft and Lerrel Pinto and Roberto Shu for insightful discussions.

References

  • Mnih et al. [2015] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
  • Silver et al. [2016] David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
  • Lillicrap et al. [2015] Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. CoRR, abs/1509.02971, 2015. URL http://arxiv.org/abs/1509.02971.
  • Peng et al. [2017] Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. arXiv preprint arXiv:1710.06537, 2017.
  • Taylor and Stone [2009] Matthew E Taylor and Peter Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10(Jul):1633–1685, 2009.
  • Devin et al. [2017] Coline Devin, Abhishek Gupta, Trevor Darrell, Pieter Abbeel, and Sergey Levine. Learning modular neural network policies for multi-task and multi-robot transfer. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pages 2169–2176. IEEE, 2017.
  • Fu et al. [2016] Justin Fu, Sergey Levine, and Pieter Abbeel. One-shot learning of manipulation skills with online dynamics adaptation and neural network priors. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on, pages 4019–4026. IEEE, 2016.
  • Pinto and Gupta [2017] Lerrel Pinto and Abhinav Gupta. Learning to push by grasping: Using multiple tasks for effective learning. ICRA, 2017.
  • Rusu et al. [2016] Andrei Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. 2016. URL https://arxiv.org/abs/1606.04671.
  • Murali et al. [2018] Adithyavairavan Murali, Lerrel Pinto, Dhiraj Gandhi, and Abhinav Gupta. CASSL: Curriculum accelerated self-supervised learning. ICRA, 2018.
  • Aravind et al. [2017] Rajeswaran Aravind, Sarvjeet Ghotra, Balaraman Ravindran, and Sergey Levine. Epopt: Learning robust neural network policies using model ensembles. ICLR, 2017. URL http://arxiv.org/abs/1610.01283.
  • Nilim and El Ghaoui [2005] A Nilim and L El Ghaoui. Robust control of markov decision processes with uncertain transition matrices. In Operations Research, pages 780–798, 2005.
  • Mandlekar et al. [2017] Ajay Mandlekar, Yuke Zhu, Li Fei-Fei, and Silvio Savarese. Adversarially robust policy learning: Active construction of physically-plausible perturbations. IROS, 2017.
  • Tobin et al. [2017] Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. 2017. URL https://arxiv.org/abs/1703.06907.
  • Al-Shedivat et al. [2017] Maruan Al-Shedivat, Trapit Bansal, Yuri Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel. Continuous adaptation via meta-learning in nonstationary and competitive environments. arXiv preprint arXiv:1710.03641, 2017.
  • Schaul et al. [2015] Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In Francis Bach and David Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pages 1312–1320, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr.press/v37/schaul15.html.
  • Gupta et al. [2017] Abhishek Gupta, Coline Devin, YuXuan Liu, Pieter Abbeel, and Sergey Levine. Learning invariant feature spaces to transfer skills with reinforcement learning. arXiv preprint arXiv:1703.02949, 2017.
  • Bocsi et al. [2013] Botond Bocsi, Lehel Csató, and Jan Peters. Alignment-based transfer learning for robot models. In Neural Networks (IJCNN), The 2013 International Joint Conference on, pages 1–7. IEEE, 2013.
  • Barrett et al. [2010] Samuel Barrett, Matthew E Taylor, and Peter Stone. Transfer learning for reinforcement learning on a physical robot. In Ninth International Conference on Autonomous Agents and Multiagent Systems-Adaptive Learning Agents Workshop (AAMAS-ALA), 2010.
  • Mahler et al. [2017] Jeffrey Mahler, Jacky Liang, Sherdil Niyaz, Michael Laskey, Richard Doan, Xinyu Liu, Juan Aparicio Ojea, and Ken Goldberg. Dex-net 2.0: Deep learning to plan robust grasps with synthetic point clouds and analytic grasp metrics. RSS, 2017.
  • Helwa and Schoellig [2017] Mohamed K. Helwa and Angela P. Schoellig. Multi-robot transfer learning: A dynamical system perspective. 2017. URL https://arxiv.org/abs/1707.08689.
  • Wang et al. [2018] Tingwu Wang, Renjie Liao, Jimmy Ba, and Sanja Fidler. Nervenet: Learning structured policy with graph neural networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id=S1sqHMZCb.
  • Sanchez-Gonzalez et al. [2018] Alvaro Sanchez-Gonzalez, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin Riedmiller, Raia Hadsell, and Peter Battaglia. Graph networks as learnable physics engines for inference and control. arXiv preprint arXiv:1806.01242, 2018.
  • Mordatch et al. [2015] Igor Mordatch, Kendall Lowrey, and Emanuel Todorov. Ensemble-cio: Full-body dynamic motion planning that transfers to physical humanoids. In Intelligent Robots and Systems (IROS), 2015 IEEE/RSJ International Conference on, pages 5307–5314. IEEE, 2015.
  • Slotine and Weiping [1988] J-JE Slotine and Li Weiping. Adaptive manipulator control: A case study. IEEE transactions on automatic control, 33(11):995–1003, 1988.
  • Park et al. [2010] Hae-Won Park, Koushil Sreenath, Jonathan Hurst, and J. W. Grizzle. System identification and modeling for mabel, a bipedal robot with a cable-differential-based compliant drivetrain. In Dynamic Walking Conference (DW), MIT, July 2010.
  • Nagarajan et al. [2009] Umashankar Nagarajan, Anish Mampetta, George A Kantor, and Ralph L Hollis. State transition, balancing, station keeping, and yaw control for a dynamically stable single spherical wheel mobile robot. In Robotics and Automation, 2009. ICRA’09. IEEE International Conference on, pages 998–1003. IEEE, 2009.
  • Abbeel et al. [2006] Pieter Abbeel, Morgan Quigley, and Andrew Y Ng. Using inaccurate models in reinforcement learning. In Proceedings of the 23rd international conference on Machine learning, pages 1–8. ACM, 2006.
  • Levine et al. [2016] Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016.
  • Kahn et al. [2017] Gregory Kahn, Tianhao Zhang, Sergey Levine, and Pieter Abbeel. Plato: Policy learning using adaptive trajectory optimization. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pages 3342–3349. IEEE, 2017.
  • Yu et al. [2017] Wenhao Yu, C Karen Liu, and Greg Turk. Preparing for the unknown: Learning a universal policy with online system identification. arXiv preprint arXiv:1702.02453, 2017.
  • Schulman et al. [2017] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/1707.06347.
  • Andrychowicz et al. [2017] Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. CoRR, abs/1707.01495, 2017. URL http://arxiv.org/abs/1707.01495.
  • [34] ROS URDF. http://wiki.ros.org/urdf.
  • Todorov et al. [2012] Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pages 5026–5033. IEEE, 2012.
  • Huo et al. [2012] Xijian Huo, Yiwei Liu, Li Jiang, and Hong Liu. Design and development of a 7-dof humanoid arm. In Robotics and Biomimetics (ROBIO), 2012 IEEE International Conference on, pages 277–282. IEEE, 2012.
  • Artstein [1980] Zvi Artstein. Discrete and continuous bang-bang and facial spaces or: look for the extreme points. SIAM Review, 22(2):172–185, 1980.
  • Erez et al. [2012] Tom Erez, Yuval Tassa, and Emanuel Todorov. Infinite-horizon model predictive control for periodic tasks with contacts. Robotics: Science and systems VII, page 73, 2012.

Appendix A Algorithms

a.1 Algorithms

In this section, we present two detailed practical algorithms based on the HCP concept. Alg. 2 is HCP based on PPO which can be used to solve tasks with dense reward. Alg. 3 is HCP based on DDPG+HER which can be used to solve multi-goal tasks with sparse reward.

Initialize PPO algorithm
Initialize a robot pool of size with robots in different dynamics and kinematics
for episode = 1, M  do
     for actor=1, K do
         Sample a robot instance
         Sample an initial state
         Retrieve the robot hardware representation vector
         Augment :
             
         for t = 0, T-1 do
              Sample action using current policy
              Execute action , receive reward , observe new state , and augmented state
         end for
         Compute advantage estimates
     end for
     for n=1,W do
         Optimize actor and critic networks with PPO via minibatch gradient descent
         if  is to be learned then
              update via gradient descent in the optimization step as well
         end if
     end for
end for
Algorithm 2 Hardware Conditioned Policy (HCP) - on-policy
Initialize DDPG algorithm
Initialize experience replay buffer
Initialize a robot pool of size with robots in different dynamics and kinematics
for episode = 1, M  do
     Sample a robot instance
     Sample a goal position and an initial state
     Retrieve the robot hardware representation vector
     Augment :
         
     for t = 0, T-1 do
         Sample action using behavioral policy
         Execute action , receive reward , observe new state , and augmented state
         Store into
     end for
     Augment with pseudo-goals via HER
     for n=1,W do
         Optimize actor and critic networks with DDPG via minibatch gradient descent
         if  is to be learned then
              update via gradient descent in the optimization step as well
         end if
     end for
end for
Algorithm 3 Hardware Conditioned Policy (HCP) - off-policy

Appendix B Experiment Details

We performed experiments on three environments in this paper: reacher, peg insertion, and hopper, as shown in Figure 7. Videos of experiments are available at: https://sites.google.com/view/robot-transfer-hcp.

(a) reacher
(b) peg insertion
(c) hopper
Figure 7: (a): reacher, the green box represents end effector initial position distribution, and the yellow box represents end effector target position distribution. (b): peg insertion. The white rings in (a) and (b) represent joints. (c): hopper.

b.1 Reacher and Peg Insertion

The reason why we choose reacher and peg insertion task is that most of manipulator tasks like welding, assembling, grasping can be seen as a sequence of reacher tasks in essence. Reacher task is the building block of many manipulator tasks. And peg insertion task can further show the control accuracy and robustness of the policy network in transferring torque control to new robots.

b.1.1 Robot Variants

During training time, we consider basic robot types (named as Type A,B,…,I) as shown in Figure 2 which have different DOF and joint placements. The -DOF and -DOF robots are created by removing joints from the -DOF robot.

We also show the length range of each link and dynamics parameter ranges in Table 2. The link name and joint name conventions are defined in Figure 8. Notice that damping values ranged from are called underdamped and overdamped systems respectively. As these systems have very different dynamics characteristics, of the damping values sampled are less than , and the rest are greater than or equal to .

Figure 8: Link name and joint name convention Table 2: Manipulator Parameters Kinematics Links Length Range (m) Dynamics damping friction armature link mass default mass

Even though we only train with robot types listed in Figure 2, our policy can be directly transferred to other new robots like the Fetch robot shown in Figure 9.

(a) J: new 5-DOF robot
(b) K: new 7-DOF robot (Fetch)
Figure 9: New types of robot. We used the model trained in Exp. V and directly applied to robot shown in (a) and Fetch robot shown in (b). We tested the model on 1000 unseen test robots (averaged over 10 trials, 100 robots per trial) of type J (as shown in (a)), and got success rate. We tested on the fetch robot in (b) 10 times and got success rate.

b.1.2 Hyperparameters

We closely followed the settings in original DDPG paper. Actions were added at the second hidden layer of . All hidden layers used scaled exponential linear unit (SELU) as the activation function and we used Adam optimizer. Other hyperparameters are summarized in Table 3.

Initial position distributions: For reacher task, the initial position of end effector is randomly sampled from a box region . For peg insertion task, all robots start from a horizontal fully-expanded pose.

Goal distributions: For reacher task, the target end effector position region is a box region which is located below the initial position sampling region. For peg insertion task, we have experiments on hole position fixed and hole position randomly moved. If the hole position is to be randomly moved, the table’s position will be randomly sampled from a box region .

Rewards: As mentioned in paper, we add action penalty on rewards so as to avoid bang-bang control. The reward is defined as: , where is the position of the point of interest (POI, end effector in reacher and peg bottom in peg insertion) after the execution of action in the state , is a hyperparameter and .

Success criterion: For reacher task, the end effector has to be within Euclidean distance to the target position to be considered as a success. For peg insertion task, the peg bottom has to be within Euclidean distance to the target peg bottom position to be considered as a success. Since the target peg bottom position is always below the table surface no matter how table moves, so the peg has to be inserted into the hole more than .

Observation noise: We add uniformly distributed observation noise on states (joint angles and joint velocities). The noise is uniformly sampled from for both joint angles () and joint velocities ().

Table 3: Hyperparameters for reacher and peg insertion tasks number of training robots for each type 140 success distance threshold maximum episode time steps actor learning rate critic learning rate critic network weight decay hidden layers -- discount factor batch size warmup episodes experience replay buffer size network training iterations after each episode soft target update number of future goals 4 action penalty coefficient 0.1 robot control frequency Table 4: Hyperparameters for hopper number of training hoppers 1000 number of actors K maximum episode time steps learning rate hidden layers - discount factor GAE parameter 0.95 clip ratio batch size dimension network training epochs after each rollout value function loss coefficient entropy loss coefficient

b.2 Hopper

Kinematics
Links Length Range (m)
torso
thigh
leg
foot
Dynamics
damping
friction
armature
link mass default mass
Table 5: Hopper Parameters

We used the same reward design as the hopper environment in OpenAI Gym. As it’s a dense reward setting, we use PPO for this task. All hidden layers used scaled exponential linear unit (SELU) as the activation function and we used Adam optimizer. Other hyperparameters are summarized in Table 4. And the sampling ranges of link lengths and dynamics are shown in Table 5.

Appendix C Supplementary Experiments

In section C.1 and section C.2, we explore the dynamics effect in manipulators. Section C.3 shows the learning curves for -DOF robots with different link lengths and dynamics. In section C.4, we show more training details of HCP-E experiments on different combinations of robot types and how well HCP-E models perform on robots that belong to the same training robot types but with different link lengths and dynamics.

c.1 Effect of Dynamics in Transferring Policies for Manipulation

Explicit encoding is made possible when knowing the dynamics of the system doesn’t help learning. In such environments, as long as the policy network is exposed to a diversity of robots with different dynamics during training, it will be robust enough to adapt to new robots with different dynamics. To show that knowing ground-truth dynamics doesn’t help training for reacher and peg insertion tasks, we experimented on 7-DOF robots (Type I) with different dynamics only with following algorithms:DDPG+HER, DDPG+HER+dynamics, DDPG+HER+random number. The first one uses DDPG+HER with only joint angles and joint velocities as the state. The second experiment uses DDPG+HER with the dynamics parameter vector added to the state. The dynamics are scaled to be within . The third experiment uses DDPG+HER with a random vector ranged from added to states that is of same size as the dynamics vector. The dynamics parameters sampling ranges are shown in Table 2. The number of training robots is .

Figure 10 shows that DDPG+HER with only joint angles and joint velocities as states is able to achieve about success rate in both reacher and peg insertion (fixed hole position) tasks. In fact, we see that even if state is augmented with a random vector, the policy network can still generalize over new testing robots, which means the policy network learns to ignore the augmented part. Figure 10 also shows that with ground-truth dynamics parameters or random vectors input to the policy and value networks, the learning process becomes slower. In hindsight, this makes sense because the dynamics information is not needed for the policy network and if we forcefully feed in those information, it will take more time for the network to learn to ignore this part and train a robust policy across robots with different dynamics.

Figure 10: Learning curves on 7-DOF robots with different dynamics only.

c.2 How robust is the policy network to changes in dynamics?

We performed a stress test on the generalization or robustness of the policy network to variation in dynamics. The experiments are similar to those in section C.1, but the training joint damping values are randomly sampled from this time. Other dynamics parameters are still randomly sampled according to Table 2. The task here is peg insertion. Figure 11 and Table 6 show the generalization capability of the DDPG + HER model with only joint angles and joint velocities as the state.

Testing damping range Success rate
Table 6: Success rate on 100 testing robots

We can see from Figure 11 and Table 6 that even though the DDPG + HER model is trained with joint damping values sampled from , it can successfully control robots with damping values sampled from other ranges including with success rate. It is noteworthy that a damping value of 1 corresponds to critical damping (which is what most practical systems aim for), while < 1 is under-damped and above is over-damped. For the damping range , the success rate is . In damping range , the success rate is . Note that each joint has a torque limit, so when damping becomes too large, the control is likely to be unable to move some joints and thus fail. Also, the larger the damping values are, the more time steps it takes to finish the peg insertion task, as shown in Figure 10(b).

(a) Distance to desired position at last step
(b) Episode length
Figure 11: Performance (violin plots) on 100 testing robots with damping values sampled from different ranges using the DDPG+HER model trained with damping range ). Other dynamics parameters are still randomly sampled according to Table 2. The left plot shows the distribution of the distances between the robot’s peg bottom and the target peg bottom position at the end of episode. The right plot shows the distribution of the episode length. An episode will be ended early if the peg is inserted into the hole successfully and the maximum number of episode time steps is . The three horizontal lines in each violin plot stand for the lower extrema, median value, and the higher extrema.

c.3 Learning curves for 7-DOF robots with different link length and dynamics

In this section, we provide two supplementary experiments on training 7-DOF (type I) to perform reacher and peg insertion task.

Figure 12: Learning curves for -DOF robots with different link length and dynamics. We show the HCP-E+Dyn learning curves only for comparison. In real robots, dynamics parameters are usually not easily accessible. So it’s not pratical to use dynamics information in robotics applications. We can see that both HCP-I and HCP-E got much higher success rates on both tasks than vanilla DDPG+HER.

c.4 Multi-DOF robots learning curves

Figure 13 provides more details of training progress in different experiments.

(a) Exp. III & IV
(b) Exp. VII & VIII
(c) Exp. IX & X
(d) Exp. XI & XII
(e) Exp. XIII & XIV
(f) Exp. XV & XVI
Figure 13: Learning curves for multi-DOF setting. Symbol A,B,…,I in the figure represent the types of robot used in training. All these experiments are only trained on types of robots (leave one out). The 100 testing robots used to generate the learning curves are from the same training robot types but with different link length and dynamics. The second row shows the results on peg insertion task with hole position randomly generated within a box region. (a): reacher task with robot types A-D + F-I. (b): peg insertion task with a fixed hole position with robot types A-D + F-I. (c): peg insertion task with a fixed hole position with robot types A-H. (d): peg insertion task with a random hole position with robot types A-G + I. (e): peg insertion task with a random hole position with robot types A-D + F-I. (f): peg insertion task with a random hole position with robot types A-H.

Table 1 in the paper shows how well HCP-E models perform when they are applied to the new robot type that has never been trained before. Table 7 to 14 show how the universal policy behaves on the robot types that have been trained before. These robots are from the training robot types, but with different link lengths and dynamics.

The less DOF the robot has, the less dexterous the robot can be. Also, where to place the joints affects the workspace of the robot and determine how flexible the robot can be. Therefore, we can see some low success rate data even in trained robot types. For example,the trained HCP-E model only got success rate when tested on robot type D which has actually been trained in peg insertion tasks with random hole positions, as shown in Table 12. This is because its joint displacements and number of DOFs limit the flexibility as shown in Figure 1(d). Type D doesn’t have joint and which are crucial for peg insertion tasks.

Alg. Testing Robot Types
A B C D E F G I
HCP-E
DDPG+HER
Table 7: Zero-shot testing performance on training robot types (Exp. I & II)
Alg. Testing Robot Types
A B C D F G H I
HCP-E
DDPG+HER
Table 8: Zero-shot testing performance on training robot types (Exp. III & IV)
Alg. Testing Robot Types
A B C D E F G I
HCP-E
DDPG+HER
Table 9: Zero-shot testing performance on training robot types (Exp. V & VI)
Alg. Testing Robot Types
A B C D E F G I
HCP-E
DDPG+HER
Table 10: Zero-shot testing performance on training robot types (Exp. VII & VIII)
Alg. Testing Robot Types
A B C D E F G H
HCP-E
DDPG+HER
Table 11: Zero-shot testing performance on training robot types (Exp. IX & X)
Alg. Testing Robot Types
A B C D E F G I
HCP-E
DDPG+HER
Table 12: Zero-shot testing performance on training robot types (Exp. XI & XII)
Alg. Testing Robot Types
A B C D F G H I
HCP-E
DDPG+HER
Table 13: Zero-shot testing performance on training robot types (Exp. XIII & XIV)
Alg. Testing Robot Types
A B C D E F G H
HCP-E
DDPG+HER
Table 14: Zero-shot testing performance on training robot types (Exp. XV & XVI)
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
Cancel
Loading ...
320293
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

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
Test description