RLBench: The Robot Learning Benchmark Learning Environment

by   Stephen James, et al.

We present a challenging new benchmark and learning-environment for robot learning: RLBench. The benchmark features 100 completely unique, hand-designed tasks ranging in difficulty, from simple target reaching and door opening, to longer multi-stage tasks, such as opening an oven and placing a tray in it. We provide an array of both proprioceptive observations and visual observations, which include rgb, depth, and segmentation masks from an over-the-shoulder stereo camera and an eye-in-hand monocular camera. Uniquely, each task comes with an infinite supply of demos through the use of motion planners operating on a series of waypoints given during task creation time; enabling an exciting flurry of demonstration-based learning. RLBench has been designed with scalability in mind; new tasks, along with their motion-planned demos, can be easily created and then verified by a series of tools, allowing users to submit their own tasks to the RLBench task repository. This large-scale benchmark aims to accelerate progress in a number of vision-guided manipulation research areas, including: reinforcement learning, imitation learning, multi-task learning, geometric computer vision, and in particular, few-shot learning. With the benchmark's breadth of tasks and demonstrations, we propose the first large-scale few-shot challenge in robotics. We hope that the scale and diversity of RLBench offers unparalleled research opportunities in the robot learning community and beyond.


page 1

page 2

page 3

page 4

page 6


Multiple Interactions Made Easy (MIME): Large Scale Demonstrations Data for Imitation

In recent years, we have seen an emergence of data-driven approaches in ...

Scalable Multi-Task Imitation Learning with Autonomous Improvement

While robot learning has demonstrated promising results for enabling rob...

Task-Embedded Control Networks for Few-Shot Imitation Learning

Much like humans, robots should have the ability to leverage knowledge f...

PyRep: Bringing V-REP to Deep Robot Learning

PyRep is a toolkit for robot learning research, built on top of the virt...

BulletArm: An Open-Source Robotic Manipulation Benchmark and Learning Framework

We present BulletArm, a novel benchmark and learning-environment for rob...

Benchmark for Skill Learning from Demonstration: Impact of User Experience, Task Complexity, and Start Configuration on Performance

In this work, we contribute a large-scale study benchmarking the perform...

The RGB-D Triathlon: Towards Agile Visual Toolboxes for Robots

Deep networks have brought significant advances in robot perception, ena...

Code Repositories


A toolkit for robot learning research.

view repo

I Introduction

Robot manipulation systems broadly fall somewhere on a spectrum ranging from traditional, modular methods, that include object recognition, state estimation, and planning, to fully end-to-end approaches that leverage deep learning and large-scale data to learn a mapping from input observations directly to motor actions, with the intuition that the ‘traditional’ modules are embedded in the weights of a deep neural network. Driven by the successful combination of large-scale data

[ILSVRC15] and deep learning algorithms in the field of computer vision [krizhevsky2012imagenet], there is now a large body of work looking at increasing the capabilities of robotic agents through the use of reinforcement learning [james20163d, kalashnikov2018qt], meta-learning [finn2017one, james2018task, yu2018one], multi-task learning [devin2017learning, hausman2018learning], etc. However, there is currently no standard in place for comparing manipulation methods in these respective areas. Although there exist benchmarks such as OpenAI Gym [brockman2016openai] and DeepMind Control Suite [tassa2018deepmind] for evaluating continuous-control reinforcement learning algorithms, their focus is not on real-world problems, and it is often the case that algorithms in these toy-benchmarks do not scale to more complex, real-world tasks. Few-shot learning methods for robotics also suffer from a lack of well defined tasks; for example, in Finn et al. [finn2017one] and James et al. [james2018task] there is a very narrow distribution of tasks, where the task of “placing a peach into a red bowl” would be considered a different task to “placing an apple in to a green bowl”. Despite the increase in these data-driven approaches, it is not clear where the ideal location on this ‘learning’ spectrum lies for complex robotics tasks that we may one day want robots performing in our homes. Given all of these problems, there seems to be a need for a benchmark that evaluates not only the diverse range of robot learning fields that are now emerging, but also a range of visually-guided manipulation approaches from both sides of the spectrum.

This motivates the need for a one-size-fits-all benchmark that allows the capability to utilise large-scale data, whilst also allowing classical systems to be compared. To that end, we present RLBench, which is an ambitious large-scale benchmark and learning environment designed to facilitate research in a number of both classical and deep-learning based robot manipulation areas. RLBench is deliberately highly challenging and forward looking. The benchmark includes 100 completely unique, hand-designed tasks ranging in difficulty (shown in Figure 1), which share a common Franka Emika Panda robot arm, featuring a range of sensor modalities, including joint angles, velocities and forces, an eye-in-hand camera and an over-the-shoulder stereo camera setup. Each of the 100 tasks comes with a number of textual descriptions and an infinite set of demonstrations made possible through our task building tools that use waypoint-based motion planning.

In this paper, we discuss a host of research areas that would benefit from this benchmark, including, but not restricted to, reinforcement learning, imitation learning, few-shot learning, multi-task learning, and geometric based methods, such as SLAM. In addition to the benchmark, we also contribute an open-source set of tools that will allow rapid development of new tasks (through the use of PyRep [james2019pyrep]) in order to improve the size and scope of the benchmark over time. To summarise, RLBench has the following 3 key aims:

  • Provide a benchmark and learning environment for both ‘robot learning’ and ‘traditional’ methods.

  • Provide the a large-scale few-shot challenge, where given M training tasks and N unseen tasks, a system must take K different demonstrations of each of the N unseen tasks, and then be able to perform these tasks in new configurations.

  • Provide a set of tools to allow easy task creation.

Fig. 1: RLBench is a large-scale benchmark consisting of 100 completely unique, hand-designed tasks. In this figure we show a sample of 24 tasks that feature in the benchmark. Example tasks include stacking a set of 6 colored blocks in a pyramid (top left), inserting a shape onto a peg (top right), finish setting up a checkers board (bottom left), and watering a plant (bottom right). To get a better understanding of the variety of tasks, please watch the video.

Ii Related Work

We review existing datasets, benchmarks, and learning environments that could be considered similar to ours in an effort to further motivate RLBench. Firstly we cover reinforcement learning benchmarks, followed by benchmarks designed specifically for manipulation.

Reinforcement Learning

Largely as a consequence of the seminal work that saw an algorithm learn to play a range of Atari 2600 video games to superhuman level directly from image pixels [mnih2015human], deep reinforcement learning (DRL) has increasingly become prevalent in the literature, leading to a number of recent further success in the games of Go [silver2016mastering], Chess [silver2017mastering], StarCraft [alphastar], and Dota [OpenAI_dota]. With the success of these approaches, there has been a surge in developing DRL algorithms to solve continuous control environments [lillicrap2015continuous, schulman2015trust, schulman2017proximal, haarnoja2018soft, fujimoto2018addressing]. These learned (continuous control) agents are usually tested on benchmarks such as OpenAI Gym [brockman2016openai] or the DeepMind Control Suite [tassa2018deepmind]

. However, apart from a small number of robotic tasks in OpenAI Gym, these benchmarks feature only toy tasks that often do not resemble real-world problems that robots will need to overcome. To combat this, many projects create their own manipulation tasks to evaluate their approach, making comparisons difficult. As a direct consequence of this, these created tasks can often succumb to unintentionally introducing another hyperparameter into the method in the form of the task design itself. For example, a method could fail on a more challenging task, and so results would only be presented for a simpler set of tasks. This is something a standard benchmark of tasks could alleviate. (We should mention the very recently announced Meta-World project

[Meta-World], a multi-task benchmark for meta-learning research in manipulation, though full documentation describing the aims of that project is not available at the time of writing.)


Most related work in benchmarking robot manipulation algorithms often concentrates on solving only one of the manipulation sub-problems, focusing on either perception, grasping, or planning. But first, we look at benchmarks that evaluate the system as a whole. The Amazon Robotics Challenge (ARC) [eppner2016lessons] was an attempt to create a benchmark for robotic picking and stowing. Although it was a successful challenge that drew many conclusions, such as the usefulness of a dual gripper and suction cup end-effector [morrison2018cartman], it was difficult to reproduce in a lab setup. The ACRV Picking Benchmark [leitner2017acrv] aimed to solve this by creating a similar, but reproducible setup to the ARC. The issue with picking and stowing is that it is but one of many possible tasks; RLBench on the other hand comes with 100 unique tasks, many of which involve some aspect of picking and placing. Similarly to ARC, the RoboCup@Home competition [wisspeintner2009robocup] is run annually, but has a greater range of tasks that must be completed. However, given that no large-scale data is given beforehand, this makes reinforcement learning and other end-to-end approaches difficult to apply in the competition. RLBench is a platform that can unify both old and new methods and compare them on an even playing field.

For evaluating imitation learning systems in particular, RoboTurk [mandlekar2018roboturk] was a recent attempt to leverage crowd sourcing to obtain data for tasks, but because of this the system has only three tasks. Whilst RoboTurk is entirely in simulation, Simitate [memmesheimer2019simitate] on the other hand is a hybrid approach, where real world observations (RGB-D camera calibrated against a motion capturing system) are combined with a simulated environment for benchmarking. In contrast to RoboTurk, we do not crowd source our demonstrations, but instead rely on an infinite supply of generated demonstrations collected via motion planners. Although Simitate offers the benefit of being partially a real-world dataset, the addition of new tasks requires time-consuming calibration and motion capturing; our system on the other hand sacrifices the real-world aspect, but in exchange we receive the ability generate a diverse range of tasks in a scalable way.

Moving on from whole-system benchmarks, there are a host of benchmarks that focus on sub-problems, for example perception datasets, from both the computer vision community (such as ILSVRC [ILSVRC15], COCO [lin2014microsoft], Pascal-VOC [everingham2015pascal], etc), and the robotics community (such as BigBIRD [singh2014bigbird], YCB-Video [xiang2017posecnn], etc). For grasping, both OpenGrasp [ulbrich2011opengrasp] and VisGraB [popovic2011grasping] are popular simulation-based benchmarks, whilst the YCB dataset [calli2015benchmarking] focuses on real-world objects. In comparison to these, RLBench allows robotic systems to be evaluated on the complete robotic pipeline, rather than limited to sub-problems such as object detection, state estimation, grasp selection, and planning.

Iii Benchmark Properties

Fig. 2: The V-REP scene consists of a Franka Panda affixed to a wooden table, surrounded by 3 directional lights. Observations include rgb, depth, and segmentation masks from an over-the-shoulder stereo camera and a eye-in-hand monocular camera, along with robot proprioceptive data, which includes joint angles, velocities, and torques, and the gripper pose. The arm can be easily swapped out for another arm if required.
Fig. 3: A sample of the visual observations given from both the over-the-shoulder stereo and eye-in-hand monocular cameras, which supply rgb, depth, and mask images.
Fig. 4: An example showing the distinction between task, variation, and episode. In this case, the ‘stack_blocks’ task has variations, each with episodes. Each variation comes with a list of textual descriptions that describes the objective. Across variations, usually target objects or colours are changed, whereas across episodes positions are changed.

When designing RLBench, we have prioritised several key properties:


Algorithms we develop should be general. In order to effectively learn inter-task relationships, a truly diverse range of tasks is needed to help avoid over-fitting.


Reproducibility is challenging in robotics as each lab has their own robotic setup. Moving to simulation solves this, but at the risk of developing solutions that may not run as well in the real-world. However, with the rise of deep-learning methods becoming more prominent in robotics, we believe it is important to find the potential and limits of these methods in a controlled, reproducible environment.


Given the amount of data modern machine learning methods need, it is important to not only have a large collection of tasks, but also the ability to produce a large number of demonstrations from these tasks.


Following on from the previous point, we hope to continue to grow this repository of tasks. Therefore it is crucial that the task building system is as easy as possible to use. By leveraging the recently released robotics toolkit, PyRep [james2019pyrep], we are able to make a broad range of tasks in a short amount of time.

Tiered Difficulty

Attempting to get robots to do a single task can be challenging let alone expecting them to do numerous tasks. We therefore wanted to have a range of tasks, including both easy tasks, such as reaching, which would be well suited to new and emerging methods, to more challenging, long-time-horizon tasks that can stress-test well known state-of-the-art algorithms in use today.


Although we cannot claim full photorealism in our rendering system, or general realistic physics, we have put substantial effort into high quality components such as using a realistic robot model, graphics with lighting and shadows and a domain randomisation rendering option in order to maximise the potential for research on sim-to-real transfer.

Iv RLBench

RLBench is an ambitious project which we hope to grow over many years. The benchmark and learning environment is built around a V-REP [rohmer2013v] and PyRep [james2019pyrep] interface. PyRep is a toolkit for robot learning research, built on top of V-REP that features a number of improvements, including speed, rendering, and flexible a API for robot control and scene manipulation. Using the combination of these two libraries, we have been able to build this ambitious benchmark, which we now describe in greater detail.

Iv-a Scene

The V-REP scene, shown in Figure 2, remains constant across all tasks and contains the Franka Emika Panda 7 DoF arm affixed to a wooden table, surrounded by 3 directional lights. As shown in Figure 3, visual observations can be perceived from a stereo camera, and a monocular wrist camera, which supply rgb, depth, and segmentation mask data on each frame. In addition to visual observations, robot proprioceptive data can be retrieved, which includes joint angles, velocities, and torques, along with the end-effector pose. Tasks are loaded into the scene and placed at the centre of the workspace. Every task starts with the same assumption that no objects are held, therefore, unlike many works in the literature, tasks that involve tools will first need to grasp the object appropriately in order to accomplish the task. Although this makes the environments considerably harder to complete, we believe it is an important assumption to make given that household robots will one day work under such conditions.

Iv-B Tasks, Variations & Episodes

RLBench employs 3 keys terms: Task, Variation, and Episode

. Each task consists of one or more variations, and from each variation, an infinite number of episodes can be drawn. Each variation of a task comes with a list of textual descriptions that verbally summarise this variation of the task, which could prove useful for human robot interaction (HRI) and natural language processing (NLP) research. A summary of this can be seen in Figure

4. Formally, we define an episode trajectory to consist of a series of observations and actions : . These episodes are sampled from a variation . Finally, we define each task to be a set of variations, .

We now motivate the need for the concept of a ‘variation’ with an example. It is naturally difficult to come up with a precise way to differentiate between tasks given their subjective nature. For example, one could argue that “pick up the apple” and “pick up the banana” are different tasks, whilst one could also equally argue that they are the same “pick up the X” task. We therefore introduce the variation concept, which allows cases like the above to be grouped as very similar tasks. Moreover, given the way the task building tools are designed (discussed in Section IV-E), the variation concept allows a convenient way of getting as much from a task definition as possible, given that there is usually only a small amount of additional work needed to generate a large number of variations for a given task.

Iv-C Environment

Users will interface with the benchmark and learning environment through the Environment class. The Environment is the entry point and can spawn child environments, called TaskEnvironment, for the tasks you are interested in solving. The environment API, which Figure 5 demonstrates, is modelled after a typical agent-environment reinforcement learning setup. Each task has a completely sparse reward of which is given only on task completion. Users have a wide variety of action spaces at their disposal, which include absolute or delta joint velocities, absolute or delta joint positions, absolute or delta joint torque, absolute or delta end-effector velocities, and finally absolute or delta end-effector poses.

Iv-D Demonstrations

RLBench, through the task building tool mentioned in Section IV-E, provides expert algorithm for each different task and their corresponding variations, allowing for demonstration episodes to be generated The episodes produced via come from using the Open Motion Planning Library [sucan2012open].

Iv-E Task Builder

Two common simulation environments in the literature today are Bullet [pybullet] and MuJoCo [todorov2012mujoco]. However, given that these are physics engines rather than robotics frameworks, it can often be cumbersome to build rich environments and integrate standard robotics tooling such as inverse and forward kinematics, user interfaces, motion libraries, and path planners. Given the scale of RLBench, we needed a tool for designing tasks as easily as possible.

The task building tool is the interface for users who wish to create new tasks to be added to the RLBench task repository. Each task has 2 associated files: a V-REP model file (.ttm), which holds all of the scene information and demo waypoints, and a python (.py) file, which is responsible for wiring the scene objects to the RLBench backend, applying variations, defining success criteria, and adding other more complex task behaviours. Figure 6 shows an example of how simple many tasks files can be.

In order to use the task creator, users must understand how tasks are initialised and placed in the scene. When a user asks for a new task from RLBench, the task is initialised by calling , and is only called once. Following that, is called at the beginning of each variation, and gets passed the variation number, which should be less than or equal to the number of variations for that task (which can be obtained by calling ). This function returns a list of strings which provide descriptions that could be associated with this variation of the task; an analysis of the frequency of words in these descriptions can be seen in top of Figure 7. Finally, is called each time a new episode (of the same variation) is requested.

1from rlbench.environment import Environment
2from rlbench.action_modes import ActionMode
3from rlbench.tasks import ReachTarget
5DATASET = ’path/to/demo/dataset’
7env = Environment(
11task = env.sample_task()
12demos = task.get_demos(2)
14agent = Agent()
17training_steps = 100
18episode_length = 100
19obs = None
20for i in range(training_steps):
21  if i % episode_length == 0:
22    descriptions, obs = task.reset()
23  action = agent.act(obs)
24  obs, reward, terminate = task.step(action)
Fig. 5: Example usage of the RLBench Environment for training a reinforcement learning agent. When using demonstrations, users can either point to a set of saved demonstrations (as shown here), or alternatively generate demonstrations on the fly.
1from rlbench.backend.task import Task
2from rlbench.backend.conditions import DetectedCondition, GraspedCondition
3from pyrep.objects.shape import Shape
4from pyrep.objects.proximity_sensor import ProximitySensor
6class TakeLidOffSaucepan(Task):
8  def init_task(self):
9    lid = Shape(’saucepan_lid’)
10    success_detector = ProximitySensor(’success’)
11    self.register_graspable_objects([lid])
12    cond_set = [
13      GraspedCondition(self.robot.gripper, lid),
14      DetectedCondition(lid, success_detector)
15    ]
16    self.register_success_conditions([cond_set])
18  def init_episode(self, index):
19    return [’take lid off the saucepan’]
21  def variation_count(self):
22    return 1
Fig. 6: An example of a task python file. When using the task building tool, users are able to simultaneously edit the V-REP scene whilst also changing the various behaviour of a task. In this example, the task is to take a lid off of a saucepan. By interfacing with the scene using PyRep, we register that the episode should terminate and be considered a success only if the saucepan lid is detected by a proximity sensor and that the lid is being held. The backend handles the randomisation of the position of the task at the beginning of each episode.

Once a task has been created, we provide a task validation tool, that attempts to collect a number of demonstrations of the designed task in order to ensure that the path planning aspect of the task only fails a small number of times. Once the validator passes, the user will be free to perform a GitHub pull request in order to contribute to the growing task repository.

V The RLBench Few-Shot Challenge ()

Fig. 7: Top shows the frequency of words in the variation descriptions with function words removed, leaving only content words. Bottom shows the average length of 5 demonstrations from a sample of 75 tasks (taken from the first variation). The tasks lengths vary from to timesteps. Longer tasks usually involve many composed sets of actions, for example, the ‘empty_dishwasher’ task involves opening the washer door, sliding out the tray, grasping a plate, and then lifting the plate out of the tray. These long-horizon tasks can facilitate interesting research in reinforcement learning in robotic tasks.

A big gap in the literature today is a means to evaluate and compare few-shot learning methods for robotics. We place particular emphasis on the few-shot regime, because much like humans, robots should have the ability to leverage knowledge from previously learned tasks in order to learn new ones quickly in new and unfamiliar environments. Despite this, most approaches in manipulation have focused on learning a single task, with a limited notion of generalisation, and no way of leveraging the knowledge to learn other tasks more efficiently.

The few pieces of work that perform few-shot learning in robotics [finn2017one, james2018task, yu2018one] focused on a very narrow definition of task and often treat a variation of the same task as another task; for example, placing a peach into a red bowl would be considered a different task to placing an apple into a green bowl. In order to develop truly general algorithms, we feel that it is important to have a diverse range of tasks to train and test on. To that end, we propose the following challenge:

Given N unseen tasks, provide the system with K different demonstrations of each of the N tasks, and then evaluate the systems ability to perform these tasks in new configurations. Specifically, we suggest the following procedure:

  • Of the 100 unique tasks, of the tasks have been selected for the test set (meta-test) which span a range of difficulties, while the rest are chosen for training (meta-train). These train-test splits will be made available on the benchmark’s webpage.

  • The training tasks can be used in any way desired by the user. RLBench supplies a large number of pre-generated demos for each task that can be downloaded, although there is also the option to generate demos on the fly (or for users to create their own).

  • During test time, the system is given K demonstrations of the unseen task (K-shot), and then success should be reported on new episodes of that same task. The only information available to the system should be the number of demos N and their corresponding observations. There must be no prior knowledge of the unseen tasks given to the system that are not included in the training tasks. Users report 1-shot, 5-shot, and 20-shot results for their method.

We purposefully call this challenge as we expect the number of tasks to grow considerably over the years; as this happens, we will create newer versions that span a broader range of tasks; therefore, we hope this versioning will ensure results remain meaningful and reproducible as the benchmark grows. State-of-the-art few-shot learning methods such as recurrent methods [santoro2016meta, duan2016rl, mishra2017simple], metric learning methods [vinyals2016matching, snell2017prototypical], and gradient based methods [finn2017model, rusu2018meta] have not been tested on such a grand scale, and we look forward to seeing how they perform on this benchmark.

Vi Other Applications & Challenges

Further to the few-shot learning challenge highlighted in Section V, we briefly overview other areas of research that could benefit from RLBench.

Reinforcement Learning

There is a large body of work in continuous control reinforcement learning that evaluate their algorithms on benchmarks such as OpenAI Gym [brockman2016openai] or DeepMind Control Suite [tassa2018deepmind]. Unlike these benchmarks, RLBench has been tailored for visually-guided manipulation, which makes this an ideal platform for evaluating current and future reinforcement learning algorithms on real-world based tasks. Moreover, given the large number of demonstrations provided, it opens up the space to accelerate and facilitate research in bootstrapping reinforcement learning policies with demonstrations in order to reduce sample complexity. In addition, with the provided eye-in-hand camera observations, we open research in partial observability or incremental estimation for continuous control tasks.

Imitation Learning

Almost all imitation learning work design their own tasks for evaluating their method, making reproducibility difficult. A set number of demonstrations are shipped with RLBench, but there is also the option in the framework to generate demonstrations on-the-fly, meaning that you cam generate an infinite amount for your imitation learning algorithm.

Sim-to-Real Transfer

Recently there has been a large amount of work in learning control policies in simulation and then transferring these to the real world [james2017transferring, peng2018sim, matas2018sim, hwangbo2019learning, bousmalis2018using, james2019sim]. The simulated Franka Panda within RLBench can be easily swapped out, with one line of code, for another arm that researchers may have in their lab; this means that sim-to-real methods could be compared more easily on a standard set of tasks. Moreover, given the task-building tool and demonstration generation that RLbench has to offer, new tasks can easily be designed to demonstrate particular features in novel sim-to-real methods.

Multi-task Learning

In contrast to few-shot learning, multi-task learning concerns itself with learning several tasks simultaneously without particularly being expected to generalise to radically different tasks at test time. In this setup, all tasks from both meta-training and meta-testing can be used during training, and then during testing, the system must be able to generalise to unseen examples of those tasks. Given the difficulty of the challenge laid out in Section V, tackling the multi-task problem could provide valuable insights to increasing performance in the few-shot domain.


Simultaneous Localisation and Mapping (SLAM) is concerned with constructing a map of an unknown environment while simultaneously keeping track of an agent’s location within it. Traditionally SLAM has been limited to navigation, virtual reality and augmented reality domains; but ultimately we can envision SLAM systems playing a key role in robots interacting with the world, i.e. a focus on more task-based SLAM. However, if we would like a manipulation system to make use of a SLAM map, it is not currently clear what the best way to represent this map is: whether it be sparse [mur2017orb, forster2014svo], dense [newcombe2011dtam, Newcombe:etal:ISMAR2011], or semi-dense [engel2014lsd]. Moreover, it is not clear what level accuracy the map would need in order to achieve a desired task. RLBench could facilitate research in unifying SLAM and manipulation more tightly.

Vii Summary and Future Work

We have presented RLBench, an attempt to accelerate research in robotic manipulation that can be used in a broad range of robotic related research. We have posed the few-shot learning challenge for manipulation, and have highlighted a number of research areas that could benefit from this large scale benchmark and learning environment.

Given the scale of this project, we envision that there may be teething problems as people begin using the platform, and so we aim to maintain and continuously improve the benchmark during launch. Further to that, we hope, along with the help of the community, to continuously expand the tasks available for both training and evaluation. We hope RLBench will become a key resource for a broad range of robot manipulation related research, and look forward to seeing what the community achieves with this diverse range of tasks.


We thank Juxi Leitner, Ankur Handa and Eugene Valassakis for insightful feedback on an early draft of this paper. Research presented here has been supported by Dyson Technology Ltd.