Learning to combine primitive skills: A step towards versatile robotic manipulation

TL;DR

This paper introduces a reinforcement learning approach for robotic manipulation that learns to combine primitive skills using visual inputs, without requiring intermediate rewards or full demonstrations, and successfully transfers from simulation to real robots.

Contribution

The method enables versatile, vision-based task planning that handles occlusions and scene changes, with efficient training from synthetic data and successful real-world transfer.

Findings

High success rates in real robot manipulation tasks

Effective training from few synthetic demonstrations

Robust performance under occlusions and dynamic scenes

Abstract

Manipulation tasks such as preparing a meal or assembling furniture remain highly challenging for robotics and vision. Traditional task and motion planning (TAMP) methods can solve complex tasks but require full state observability and are not adapted to dynamic scene changes. Recent learning methods can operate directly on visual inputs but typically require many demonstrations and/or task-specific reward engineering. In this work we aim to overcome previous limitations and propose a reinforcement learning (RL) approach to task planning that learns to combine primitive skills. First, compared to previous learning methods, our approach requires neither intermediate rewards nor complete task demonstrations during training. Second, we demonstrate the versatility of our vision-based task planning in challenging settings with temporary occlusions and dynamic scene changes. Third, we propose an efficient training of basic skills from few synthetic demonstrations by exploring recent CNN architectures and data augmentation. Notably, while all of our policies are learned on visual inputs in simulated environments, we demonstrate the successful transfer and high success rates when applying such policies to manipulation tasks on a real UR5 robotic arm.

Tables

Table 1. TABLE III: Comparison of RLBC with 3 baselines on the real-world UR5-Bowl task with dynamic changes of the cube position, dynamic occlusions and new object instances.

UR5-Bowl perturbations	Detect & Plan	Detect & Replan	BC-ordered	RLBC
No perturbations	17/20	16/20	17/20	20/20
Moving objects	0/20	12/20	13/20	20/20
Occlusions	17/20	10/20	2/20	18/20
New objects	16/20	14/20	15/20	18/20

Full text

11footnotetext: Inria, École normale supérieure, CNRS, PSL Research University, 75005 Paris, France.22footnotetext: University Grenoble Alpes, Inria, CNRS, Grenoble INP, LJK, 38000 Grenoble, France.11footnotetext: Equal contribution.

I Introduction

In this work we consider visually guided robotics manipulations and aim to learn robust visuomotor control policies for particular tasks. Autonomous manipulations such as assembling IKEA furniture [1] remain highly challenging given the complexity of real environments as well as partial and uncertain observations provided by the sensors. Successful methods for task and motion planning (TAMP) [2, 3, 4] achieve impressive results for complex tasks but often rely on limiting assumptions such as the full state observability and known 3D shape models for manipulated objects. Moreover, TAMP methods usually complete planning before execution and are not robust to dynamic scene changes.

Recent learning methods aim to learn visuomotor control policies directly from image inputs. Imitation learning (IL) [5, 6, 7, 8] is a supervised approach that can be used to learn simple skills from expert demonstrations. One drawback of IL is its difficulty to handle new states that have not been observed during demonstrations. While increasing the number of demonstrations helps to alleviate this issue, an exhaustive sampling of action sequences and scenarios becomes impractical for long and complex tasks.

In contrast, reinforcement learning (RL) requires little supervision and achieves excellent results for some challenging tasks [9, 10]. RL explores previously unseen scenarios and, hence, can generalize beyond expert demonstrations. As full exploration is exponentially hard and becomes impractical for problems with long horizons, RL often relies on careful engineering of rewards designed for specific tasks.

Common tasks such as preparing food or assembling furniture require long sequences of steps composed of many different actions. Such tasks have long horizons and, hence, are difficult to solve by either RL or IL methods alone. To address this issue, we propose a RL-based method that learns to combine simple imitation-based policies. Our approach simplifies RL by reducing its exploration to sequences with a limited number of primitive actions, that we call skills.

Given a set of pre-trained skills such as "grasp a cube" or "pour from a cup", we train RL with sparse binary rewards corresponding to the correct/incorrect execution of the full task. While hierarchical policies have been proposed in the past [11, 12], our approach can learn composite manipulations using no intermediate rewards and no demonstrations of full tasks. Hence, the proposed method can be directly applied to learn new tasks. See Figure 1 for an overview of our approach.

Our skills are low-level visuomotor controllers learned from synthetic demonstrated trajectories with behavioral cloning (BC) [5]. Examples of skills include go to the bowl, grasp the object, pour from the held object, release the held object, etc. We automatically generate expert synthetic demonstrations and learn corresponding skills in simulated environments. We also minimize the number of required demonstrations by choosing appropriate CNN architectures and data augmentation methods. Our approach is shown to compare favorably to the state of the art [7] on the FetchPickPlace test environment [13]. Moreover, using recent techniques for domain adaptation [14] we demonstrate the successful transfer and high accuracy of our sumulator-trained policies when tested on a real robot

We compare our approach with two classical methods: (a) an open-loop controller estimating object positions and applying a standard motion planner (b) a closed-loop controller adapting the control to re-estimated object positions. We show the robustness of our approach to a variety of perturbations. The perturbations include dynamic change of object positions, new object instances and temporary object occlusions. The versatility of learned policies comes from both the reactivity of the BC learned skills and the ability of the RL master policy to re-plan in case of failure. Our approach allows to compute adaptive control and planning in real-time.

In summary, this work makes the following contributions. (i) We propose to learn robust RL policies that combine BC skills to solve composite tasks. (ii) We present sample efficient training of BC skills and demonstrate an improvement compared to the state of the art. (iii) We demonstrate successful learning of relatively complex manipulation tasks with neither intermediate rewards nor full demonstrations. (iv) We successfully transfer and execute policies learned in simulation to real robot setups. (v) We show successful task completion in the presence of perturbations.

Our simulation environments together with the code and models used in this work is publicly available at https://www.di.ens.fr/willow/research/rlbc/.

II Related work

Our work is related to robotics manipulation such as grasping [15], opening doors [16], screwing the cap of a bottle [17] and cube stacking [18]. Such tasks have been addressed by various methods including imitation learning (IL) [19] and reinforcement learning (RL) [20].

Imitation learning (IL). A neural network is trained to solve a task by observing demonstrations. Approaches include behavioral cloning (BC) [5] and inverse reinforcement learning [8]. BC learns a function that maps states to expert actions [6, 7], whereas inverse reinforcement learning learns a reward function from demonstrations in order to solve the task with RL [21, 22, 18]. BC typically requires a large number of demonstrations and has issues with not observed trajectories. While these problems might be solved with additional expert supervision [6] or noise injection in expert demonstrations [23], we address them by improving the standard BC framework. We use recent state-of-the-art CNN architectures and data augmentation for expert trajectories. This permits to significantly reduce the number of required demonstrations and to improve performance.

Reinforcement learning (RL). RL learns to solve a tasks without demonstrations using exploration. Despite impressive results in several domains [10, 9, 24, 16], RL methods show limited capabilities when operating in complex and sparse-reward environments common in robotics. Moreover, RL methods typically require prohibitively large amounts of interactions with the environment during training. Hierarchical RL (HRL) methods alleviate some of these problems by learning a high-level policy modulating low-level workers. HRL approaches are generally based either on options [25] or a feudal framework [26]. The option methods learn a master policy that switches between separate skill policies [27, 28, 29, 30]. The feudal approaches learn a master policy that modulates a low-level policy by a control signal [31, 32, 33, 34, 35]. Our approach is based on options but in contrast to the cited methods, we pretrain the skills with IL. This allows us to solve complex and sparse reward problems using significantly less interactions with the environment during training.

Combining RL and IL. A number of approaches combining RL and IL have been introduced recently. Gao et al. [36] use demonstrations to initialize the RL agent. [37, 38] use RL to improve expert demonstrations, but do not learn hierarchical policies. Demonstrations have been also used to define RL objective functions [39, 40] and rewards [41]. Das et al. [11] combines IL and RL to learn a hierarchical policy. Unlike our method, however, [11] requires full task demonstrations and task-specific reward engineering. Moreover, the addressed navigation problem in [11] has a much lower time horizon compared to our tasks. [11] also relies on pre-trained CNN representations which limits its application domain. Le at al. [12] train low-level skills with RL, while using demonstrations to switch between skills. In a reverse manner, we use IL to learn low-level control and then deploy RL to find appropriate sequences of pre-trained skills. The advantage is that our method can learn a variety of complex manipulations without full task demonstrations. Moreover, [11, 12] learn discrete actions and cannot be directly applied to robotics manipulations that require continous control.

In summary, none of the methods [11, 12, 37, 38] is directly suitable for learning complex robotic manipulations due to requirements of dense rewards [11, 38] and state inputs [37, 38], limitations to short horizons and discrete actions [11, 12], the requirement of full task demonstrations [11, 12, 37, 38] and the lack of learning of visual representations [11, 37, 38]. Moreover, our skills learned from synthetic demonstrated trajectories outperform RL based methods, see Section V-D.

III Approach

Our RLBC approach aims to learn multi-step policies by combining reinforcement learning (RL) and pre-trained skills obtained with behavioral cloning (BC). We present BC and RLBC in Sections III-A and III-B. Implementation details are given in Section III-C.

III-A Skill learning with behavioral cloning

Our first goal is to learn basic skills that can be composed into more complex policies. Given observation-action pairs $\mathcal{D}=\{(o_{t},a_{t})\}$ along expert trajectories, we follow the behavioral cloning approach [5] and learn a function approximating the conditional distribution of the expert policy $\pi_{\textrm{E}}(a_{t}|o_{t})$ controlling a robot arm. Our observations $o_{t}\in\mathcal{O}=\mathbb{R}^{\textrm{H}\times\textrm{W}\times\textrm{M}}$ are sequences of the last $M$ depth frames. Actions $a_{t}=(\mathbf{v}_{t},\bm{\omega}_{t},g_{t})$, $a_{t}\in\mathcal{A}^{\textrm{BC}}$ are defined by the end-effector linear velocity $\mathbf{v}_{t}\in\mathbb{R}^{3}$ and angular velocity $\bm{\omega}_{t}\in\mathbb{R}^{3}$ as well as the gripper openness state $g_{t}\in\{0,1\}$.

We learn the deterministic skill policies $\pi_{s}\mathrel{\mathop{\mathchar 58\relax}}\mathcal{O}\to\mathcal{A}^{\textrm{BC}}$ approximating the expert policy $\pi_{\textrm{E}}$. Given observations $o_{t}$ with corresponding expert (ground truth) actions $a_{t}=(\mathbf{v}_{t},\bm{\omega}_{t},g_{t})$, we represent $\pi_{s}$ with a convolutional neural network (CNN) and learn network parameters $(\theta,\eta)$ such that predicted actions $\pi_{s}(o_{t})=(\mathbf{\hat{v}}_{t},\bm{\hat{\omega}}_{t},\hat{g_{t}})$ minimize the loss $L_{\textrm{BC}}(\pi_{s}(o_{t}),a_{t})=\lambda\left\lVert[\mathbf{\hat{v}_{t}},\bm{\hat{\omega}}_{t}]-[\mathbf{v}_{t},\bm{\omega}_{t}]\right\rVert^{2}_{2}+(1-\lambda)\left(g_{t}\log{\hat{g_{t}}}+(1-g_{t})\log{(1-\hat{g_{t}})}\right)$, where $\lambda\in[0,1]$ is a scaling factor which we empirically set to 0.9.

Our network architecture is presented in Figure 1(right). When training a skill policy $\pi_{s}^{i}$, such as reaching, grasping or pouring, we condition the network on the skill using the recent FiLM architecture [42]. Given the one-hot encoding $s^{i}$ of a skill $i$, we use $s^{i}$ as input to the FiLM generator which performs affine transformations of the network feature maps. FiLM conditions the network on performing a given skill, which permits learning a shared representation for all skills. Given an observation $o_{t}$, the network $CNN(\theta|s^{i})$ generates a feature map $x^{i}_{t}$ conditioned on skill $i$. The spatially-averaged $x_{i}$ is linearly mapped with $FC(\eta)$ to the action of $\pi_{s}^{i}$.

III-B RLBC approach

We wish to solve composite manipulations without full expert demonstrations and with a single sparse reward. For this purpose we rely on a high-level master policy $\pi_{m}$ controlling the pre-trained skill policies $\pi_{s}$ at a coarse timescale. To learn $\pi_{m}$, we follow the standard formulation of reinforcement learning and maximize the expected return $\mathbb{E}_{\pi}\sum_{k=0}^{\infty}\gamma^{k}r_{t+k}$ given rewards $r_{t}$. Our reward function is sparse and returns $1$ upon successful termination of the task and [math] otherwise. The RL master policy $\pi_{m}\mathrel{\mathop{\mathchar 58\relax}}\mathcal{O}\times\mathcal{A}^{\textrm{RL}}\to[0,1]$ chooses one of the $K$ skill policies to execute the low-level control, i.e., the action space of $\pi_{m}$ is discrete: $\mathcal{A}^{\textrm{RL}}=\{1,\ldots,K\}$. Note, that our sparse reward function makes the learning of deep visual representations challenging. We, therefore, train $\pi_{m}$ using visual features $x_{t}^{i}$ obtained from the BC pre-trained $CNN(\theta|s^{i})$. Given an observation $o_{t}$, we use the concatenation of skill-conditioned features $\{x^{1}_{t},\ldots,x^{K}_{t}\}$ as input for the master $CNN(\mu)$, see Figure 1(right).

To solve composite tasks with sparse rewards, we use a coarse timescale for the master policy. The selected skill policy controls the robot for $n$ consecutive time-steps before the master policy is activated again to choose a new skill. This allows the master to focus on high-level task planning rather than low-level motion planning achieved by the skills. We expect the master policy to recover from unexpected events, for example, if an object slips out of a gripper, by re-activating an appropriate skill policy. Our combination of the master and skill policies is illustrated in Figure 1(left).

RLBC algorithm. The pseudo-code for the proposed approach is shown in Algorithm 1. The algorithm can be divided into three main steps. First, we collect a dataset of expert trajectories $\mathcal{D}_{k}$ for each skill policy $\pi^{k}_{s}$. For each policy, we use an expert script that has an access to the full state of the environment. Next, we train a set of skill policies $\{\pi^{1}_{s},\ldots,\pi^{K}_{s}\}$. We sample a batch of state-action pairs and update parameters of convolutional layers $\theta$ and the skills linear layer parameters $\eta$. Finally, we learn the master $\pi_{m}$ using the pretrained skill policies and the frozen parameters $\theta$. We collect episode rollouts by first choosing a skill policy with the master and then applying the selected skill to the environment for $n$ time-steps. We update the master policy weights $\mu$ to maximize the expected sum of rewards.

III-C Approach details

Skill learning with BC. We use ResNet-18 for the $CNN(\theta|s^{i})$, which we compare to VGG16 and ResNet-101 in Section V-A. We augment input depth frames with random translations, rotations and crops. We also perform viewpoint augmentation and sample the camera positions on a section of a sphere centered on the robot and with a radius of $1.40\,\text{m}$. We uniformly sample the yaw angle in $[-15\degree,15\degree]$, the pitch angle in $[15\degree,30\degree]$, and the distance to the robot base in $[1.35,1.50]$ m. The impact of both augmentations is evaluated in Section V-B. We normalize the ground truth of the expert actions to have zero mean and a unit variance and normalize the depth values of input frames to $[-1,1]$. We learn BC skills using Adam [43] with the learning rate $10^{-3}$ and a batch size 64. We also use Batch Normalization [44].

Task learning with RL. We learn the master policies with the PPO [45] algorithm using the open-source implementation [46] where we set the entropy coefficient to 0.05, the value loss coefficient to 1, and use 8 episode rollouts for the PPO update. For the RLBC method, the concatenated skill features $\{x_{t}^{1},\ldots,x_{t}^{K}\}$ are processed with the master network $CNN(\mu)$ having 2 convolutional layers with 64 filters of size $3\times 3$. During pre-training of skill policies we update the parameters $(\theta,\eta)$. When training the master policy, we only update $\mu$ while keeping ($\theta$, $\eta$) parameters fixed. We train RLBC using 8 different random seeds in parallel and evaluate the best one.

Real robot transfer. To apply our method on the real robot, we use a state-of-the-art technique of learning sim2real transfer based on data augmentation with domain randomization [14]. This method uses a proxy task of cube position prediction and a set of basic image transformations to learn a sim2real data augmentation function for depth images. We augment the depth frames from synthetic expert demonstrations with this method and, then, train skill policies. Once the skill policy is trained on these augmented simulation images, it is directly used on the real robot.

IV Experimental setup

This section describes the setup used to evaluate our approach. First, we present the robot environment and the different tasks in Sections IV-A and IV-B. Next, we describe the synthetic dataset generation and skill definition for each task in Sections IV-C and IV-D.

IV-A Robot and agent environment

For our experiments we use a 6-DoF UR5 robotic arm with a 3 finger Robotiq gripper, see Figure 2. In simulation, we model the robot with the pybullet physics simulator [47]. For observation, we record depth images with the Microsoft Kinect 2 placed in front of the arm. The agent takes as input the three last depth frames $o_{t}\in\mathbb{R}^{224\times 224\times 3}$ and commands the robot with an action $a_{t}\in\mathbb{R}^{7}$. The control is performed at 10 Hz frequency.

IV-B UR5 tasks

For evaluation, we consider 3 tasks: UR5-Pick, UR5-Bowl and UR5-Breakfast. The UR5-Pick task picks up a cube of a size between 3.5 cm and 8.0 cm and lifts it up, see Figure 2(a). In UR5-Bowl the robot has to grasp the cube and place it in the bowl, see Figure 2(b). The UR5-Breakfast task contains a cup, a bottle and a bowl as shown in Figure 2(c). We use distinct ShapeNet [48] object instances for the training and test sets (27 bottles, 17 cups, 32 bowls in each set). The robot needs to pour ingredients from the cup and the bottle in the bowl. In all tasks, the reward is positive if and only if the task goal is reached. The maximum episode lengths are 200, 600, and 2000 time-steps for UR5-Pick, UR5-Bowl, and UR5-Breakfast correspondingly.

IV-C Synthetic datasets

We use the simulated environments to create a synthetic training and test set. For all our experiments, we collect trajectories with random initial configurations where the objects and the end-effector are allocated within a workspace of $80\times 40\times 20\,\text{cm}^{3}$. The synthetic demonstrations are collected using an expert script designed for each skill. The script has access to the full state of the system including the states of the robot and the objects. To generate synthetic demonstrations, we program end-effector trajectories and use inverse kinematics (IK) to generate corresponding trajectories in the robot joints space. Each demonstration consists of multiple pairs of the three last camera observations and the robot control command performed by the expert script. For UR5-Pick, we collect $1000$ synthetic demonstrated trajectories for training. For UR5-Bowl and UR5-Breakfast, we collect a training dataset of 250 synthetic demonstrations. For evaluation of each task, we use 100 different initial configurations in simulation and 20 trials on the real robot.

IV-D Skill definition

UR5-Pick task is defined as a single skill. For UR5-Bowl and UR5-Breakfast, we consider a set of skills defined by expert scripts. For UR5-Bowl, we define four skills: (a) go to the the cube, (b) go down and grasp, (c) go up, and (d) go to the bowl and open the gripper. For UR5-Breakfast, we define four skills: (a) go to the bottle, (b) go to the cup, (c) grasp an object and pour it to the bowl, and (d) release the held object. We emphasize that the expert dataset does not contain full task demonstrations and that all our training is done in simulation. When training the RL master, we execute selected skills for 60 consecutive time-steps for the UR5-Bowl task and 220 time-steps for the UR5-Breakfast task.

V Evaluation of BC skill learning

This section evaluates the different parameters of the BC skill training for the UR5-Pick task and a comparison with the state of the art. First, we evaluate the impact of the CNN architecture and data augmentation on the skill performance in Sections V-A and V-B. Then, we show that the learned policies transfer to a real-robot in Section V-C. Finally, we compare the BC skills with the state of the art in Section V-D.

V-A CNN architecture for BC skill learning

Given the simulated UR5-Pick task illustrated in Figure 2(a)(left), we compare BC skill networks trained with different CNN architectures and varying number of expert demonstrations. Table I compares the success rates of policies with VGG and ResNet architectures. Policies based on the VGG architecture [49] obtain success rate below $40\%$ with $100$ training demonstrations and reach $95\%$ with $1000$ demonstrations. ResNet [50] based policies have a success rate above $60\%$ when trained on a dataset of $100$ demonstrations and reach $100\%$ with $1000$ demonstrations. Overall ResNet-101 has the best performance closely followed by ResNet-18 and outperforms VGG significantly. To conclude, we find that the network architecture has a fundamental impact on the BC performance. In the following experiments we use ResNet-18 as it presents a good trade-off between performance and training time.

When examining why VGG-based BC has a lower success rate, we observe that it has higher validation errors compared to ResNet. This indicates that VGG performs worse on the level of individual steps and is hence expected to result in higher compounding errors.

V-B Evaluation of data augmentation

We evaluate the impact of different types of data augmentations in Table II. We compare training without data augmentation with 3 variants: (1) random translations, rotations and crops, as is standard for object detection, (2) record each expert synthetic demonstration from 10 varying viewpoints and (3) the combination of (1) and (2).

Success rates for UR5-Pick on datasets with 20, 50 and 100 demonstrations are reported in Table II. We observe that data augmentation is particularly important when only a few demonstrations are available. For 20 demonstrations, the policy trained with no augmentation performs at 1% while the policy trained with standard and viewpoint augmentations together performs at 75%. The policy trained with a combination of both augmentation types performs the best and achieves 93% and 100% success rate for 50 and 100 demonstrations respectively. In summary, data augmentation allows a significant reduction in the number of expert trajectories required to solve the task.

V-C Real robot experiments

We evaluate our method on the real-world UR5-Pick illustrated in Figure 2(a)(right). We collect demonstrated trajectories in simulation and train the BC skills network applying standard, viewpoint and sim2real augmentations. We show that our approach transfers well to the real robot using no real images. The learned policy manages to pick up cubes of 3 different sizes correctly in 20 out of 20 trials.

V-D Comparison with state-of-the-art methods

One of the few test-beds for robotic manipulation is FetchPickPlace from OpenAI Gym [13] implemented in mujoco [51], see Figure 3(a). The goal for the agent is to pick up a cube and to move it to the red target (see Figure 3(a)). The agent observes the three last RGB-D images from a camera placed in front of the robot $o_{t}\in\mathbb{R}^{100\times 100\times 4\times 3}$. The positions of the cube and the target are set at random for each trial. The reward of the task is a single sparse reward of success. The maximum length of the task is 50 time-steps.

For a fair comparison with [7], we do not use any data augmentation. We report the success rate of ResNet-18 policy in Figure 3(b). We follow [7] and plot the success rate of both RL and IL methods with respect to the number of episodes used (either trial episodes or demonstrations). Our approach outperforms the policies trained with an imitation learning method DAgger [6] in terms of performance and RL methods such as HER [52] and DDPG [53] in terms of data-efficiency. According to [7], DAgger does not reach 100% even after $8*10^{4}$ demonstrations despite the fact that it requires an expert during training. HER reaches the success rate of 100% but requires about $4*10^{4}$ trial episodes. Our approach achieves the 96% success rate using $10^{4}$ demonstrations.

Our policies differ from [7] mainly in the CNN architecture. Pinto et al. [7] use a simple CNN with 4 convolutional layers while we use ResNet-18. Results of this section confirm the large impact of the CNN architecture on the performance of visual BC policies, as was already observed in Table I.

VI Evaluation of RLBC

This section evaluates the proposed RLBC approach and compares it to baselines introduced in Section VI-A. First, we evaluate our method on UR5-Bowl in Section IV-B. We then test the robustness of our approach to various perturbations such as dynamic changes of object positions, dynamic occlusions, unseen object instances and the increased probability of collisions due to small distances between objects. We show that RLBC outperforms the baselines on those scenarios both in simulation and on a real robot. Note, that our real robot experiments are performed with skills and master policies that have been trained exclusively in simulation using sim2real augmentation [14]. We use the same policies for all perturbation scenarios. Qualitative results of our method are available in the supplementary video.

VI-A Baseline methods

We compare RLBC with 3 baselines: (a) a fixed sequence of BC skills following the manually pre-defined correct order (BC-ordered); (b) an open-loop controller estimating positions of objects and executing an expert script (Detect & Plan); (c) a closed-loop controller performing the same estimation-based control and replanning in case if object positions change substantially (Detect & Replan). We use the same set of skills for RLBC and BC-ordered. We train the position estimation network using a dataset of 20.000 synthetic depth images with randomized object positions. All networks use ResNet-18 architecture and are trained with the standard, viewpoint and sim2real augmentations described in Section V-B.

VI-B Results on UR5-Bowl with no perturbations

We first evaluate RLBC and the three baselines on the UR5-Bowl task (see Figure 2(b)). When tested in simulation, all the baselines and RLBC manage to perfectly solve the task. On the real-world UR5-Bowl task, BC-ordered and Detect & Plan baselines sometimes fail to grasp the object which leads to task failures (see Table III, first row). On the contrary, RLBC solves the task in all 20 episodes given its ability to re-plan the task in the cases of failed skills.

We have also attempted to solve the simulated UR5-Bowl task without skills by learning an RL policy performing low-level control. We have used ImageNet pre-trained ResNet-18 to generate visual features. The features were then used to train low-level RL control policy with PPO. Whereas such a low-level RL policy did not solve the task a single time after $10^{4}$ episodes, RLBC reaches 100% after 400 episodes.

VI-C Robustness to perturbations

Robustness to dynamic changes in object position. We evaluate RLBC against the baselines in the UR5-Bowl scenario where the cube is moved several times during the episode. We plot success rates evaluated in simulation with respect to the number of position changes in Figure 4(a). We observe the stability of RLBC and the fast degradation of all baselines. As both RLBC and BC-ordered use the same set of skills, the stability of RLBC comes from the learned skill combination. The "Moving objects" row in Table III reports results for 3 moves of the cube evaluated on the real robot. Similar to simulated results, we observe excellent results of RLBC and the degraded performance for all the baselines.

Robustness to occlusions. We evaluate the success of UR5-Bowl task under occlusions. Each occlusion lasts 3 seconds and covers a large random part of the workspace by a cardboard. Figure 4(b) shows success rates with respect to the number of occlusions in the simulated UR5-Bowl environment. Similar to perturbation results in Figure 4(a), RLBC demonstrates high robustness to occlusions while the performance of other methods quickly degrades. The "Occlusions" row in Table III reports results for a single occlusion performed during the real-robot evaluation. Baseline methods are strongly influenced by occlusions except Detect & Plan which performs well unless occlusion happens during the first frames. Our HRBC policy performs best compared to other methods.

Robustness to new object instances. We evaluate the robustness of methods to the substitution of a cube by other objects not seen during the training of UR5-Bowl task. Figure 4(c) shows the success rate of RLBC and other methods with respect to the number of new objects in simulation. The novel objects are ordered by their dissimilarity with the cube. The difficulty of grasping unseen objects degrades the performance of grasping skills. In contrast to other methods RLBC is able to automatically recover from errors by making several grasping attempts. Table III reports corresponding results on a real robot where the cube has been replaced by 10 unseen objects. Similar to other perturbations we observe superior performance of RLBC.

Impact of the distance between objects. We vary the distance between a bottle and a cup in the UR5-Breakfast task. The smaller distance between objects A and B implies higher probability of collision between a robot and A when grasping B behind A. The choice of the grasping order becomes important in such situations. While our method is able to learn the appropriate grasping order to maximize the chance of completing the task, the BC-ordered and other baselines use pre-defined order. Figure 4(d) demonstrates the performance of RLBC and BC-ordered for different object distances in the simulated UR5-Breakfast task. As expected, RLBC learns the correct grasping order and avoids most of collisions. The performance of BC-ordered strongly degrades with the decreasing distance. In the real-world evaluation, both RLBC and ordered skills succeed in 16 out of 20 episodes when the distance between objects is larger than 10 cm. However, the performance of BC-ordered drops to 8/20 when the cup and the bottle are at $4$cm from each other. In contrast, RLBC chooses the appropriate object to avoid collisions and succeeds in 16 out of 20 trials.

VII Conclusion

This paper presents a method to learn combinations of primitive skills. Our method requires no full-task demonstrations nor intermediate rewards and shows excellent results in simulation and on a real robot. We demonstrate the versatility of our approach in challenging settings with dynamic scene changes. Future work will include learning multiple tasks with shared skills and addressing contact-rich tasks.