A Survey on Policy Search Algorithms for Learning Robot Controllers in a Handful of Trials

Most policy search (PS) algorithms require thousands of training episodes to find an effective policy, which is often infeasible with a physical robot. This survey article focuses on the extreme other end of the spectrum: how can a robot adapt with only a handful of trials (a dozen) and a few minutes? By analogy with the word “big-data,” we refer to this challenge as “micro-data reinforcement learning.” In this article, we show that a first strategy is to leverage prior knowledge on the policy structure (e.g., dynamic movement primitives), on the policy parameters (e.g., demonstrations), or on the dynamics (e.g., simulators). A second strategy is to create data-driven surrogate models of the expected reward (e.g., Bayesian optimization) or the dynamical model (e.g., model-based PS), so that the policy optimizer queries the model instead of the real system. Overall, all successful micro-data algorithms combine these two strategies by varying the kind of model and prior knowledge. The current scientific challenges essentially revolve around scaling up to complex robots, designing generic priors, and optimizing the computing time.


I. INTRODUCTION
R EINFORCEMENT learning (RL) [1] is a generic framework that allows robots to learn and adapt by trial and error. There is currently a renewed interest in RL owing to recent advances in deep learning [2]. For example, RL-based agents can now learn to play many of the Atari 2600 games directly from pixels [3], [4], that is, without explicit feature engineering, and beat the world's best players at Go and chess with minimal human knowledge [5]. Unfortunately, these impressive successes are difficult to transfer to robotics because the algorithms behind them are highly data-intensive: 4.8 million games were required to learn to play Go from scratch [5], 38 days of play (real time) for Atari 2600 games [3], and, for example, about 100 h of simulation time (much more for real time) for a nine-degrees of freedom (9-DOF) mannequin that learns to walk [6].
By contrast, robots have to face the real world, which cannot be accelerated by GPUs nor parallelized on large clusters. The real world will not become faster in a few years, contrary to computers so far (Moore's law). In concrete terms, this means that most of the experiments that are successful in simulation cannot be replicated in the real world because they would take too much time to be technically feasible. As an example, Levine et al. [7] recently proposed a large-scale algorithm for learning hand-eye coordination for robotic grasping using deep learning. The algorithm required approximately 800 000 grasps, which were collected within a period of two months using 6-14 robotic manipulators running in parallel. Although the results are promising, they were only possible because they could afford having that many manipulators and because manipulators are easy to automate: it is hard to imagine doing the same with a farm of humanoids.
What is more, online adaptation is much more useful when it is fast than when it requires hours-or worse, days-of trial and error. For instance, if a robot is stranded in a nuclear plant and has to discover a new way to use its arm to open a door; or if a walking robot encounters a new kind of terrain for which it is required to alter its gait; or if a humanoid robot falls, damages its knee, and needs to learn how to limp: in most cases, adaptation has to occur in a few minutes or within a dozen trials to be of any use.
By analogy with the word "big-data," we refer to the challenge of learning by trial and error in a handful of trials as "micro-data RL" [8]. This concept is close to "data-efficient RL" [9], but we think it captures a slightly different meaning. The main difference is that efficiency is a ratio between a cost and benefit, that is, data-efficiency is a ratio between a quantity of data and, for instance, the complexity of the task. In addition, efficiency is a relative term: a process is more efficient than another; it is not simply "efficient." In that sense, many deep learning algorithms are data-efficient because they require fewer trials than the previous generation, regardless of the fact that they might need millions of time-steps. By contrast, we propose the terminology "micro-data learning" to represent an absolute value, not a relative one: how can a robot learn in a few minutes of interaction? or how can a robot learn in less than 20 trials? 1 Importantly, a micro-data algorithm might reduce the number of trials by incorporating appropriate prior knowledge; this does not necessarily make it more "data-efficient" than another algorithm that would use more trials but less prior knowledge: it simply makes them different because the two algorithms solve a different challenge.
Among the different approaches for RL, most of the recent work in robotics focuses on policy search (PS), that is, on viewing the RL problem as the optimization of the parameters of a given policy [10] (see the problem formulation, Section II). A few PS algorithms are explicitly focused on requiring very little interaction time with the robot, which often implies that they authorize themselves to substantially increase the computing time and the amount of prior knowledge. The purpose of this article is to survey such existing micro-data policy search (MDPS) techniques that have been successfully used for robot control, 2 and to identify the challenges in this emerging field. In particular, we focus on PS approaches that have the explicit goal of reducing the interaction time between the robot and the environment to a few seconds or minutes. 3 1 It is challenging to put a precise limit for "micro-data learning" as each domain has different experimental constraints, this is why we will refer in this article to "a few minutes" or a "a few trials." The commonly used word "big-data" has a similar "fuzzy" limit that depends on the exact domain. 2 Planning-based and MPC [11] methods do not search for policy parameters, this is why they do not fit into the scope of this article. Although trajectorybased policies and planning-based methods share the same goal, they usually search in a different space: planning algorithms search in the state-action space (e.g., joint positions/velocities), whereas policy methods will search for the optimal parameters of the policy, which can encode a subspace of the possible trajectories. 3 The scarcity of data in robotics makes it necessary to follow specific strategies when designing learning algorithms. The authors of the present survey organized a very successful workshop on this exact topic at IROS 2017 (Micro-Data: the Most published algorithms for MDPS implement and, sometimes, combine two main strategies (see Fig. 1): leveraging prior knowledge (Sections III, IV-B, and V-B) and building surrogate models (Sections IV and V).
Using prior knowledge requires balancing carefully between what can be realistically known before learning and what is left to be learnt. For instance, some experiments assume that demonstrations can be provided, but that they are imperfect [13], [14]; some others assume that a damaged robot knows its model in its intact form, but not the damaged model [15]- [17]. This knowledge can be introduced at different places, typically in the structure of the policy (e.g., dynamic movement primitives [18], Section III), in the reward function (e.g., reward shaping, Section IV-B), or in the dynamical model [17], [19] (see Section V-B).
The second strategy is to create models from the data gathered during learning and utilize them to make better decisions about what to try next on the robot. We can further categorize these methods into 1) algorithms that learn a surrogate model of the expected return (i.e., long-term reward) from a starting state [20], [21] (see Section IV); and 2) algorithms that learn models of the transition dynamics and/or the immediate reward function (e.g., learning a controller for inverted helicopter flight by first learning a model of the helicopter's dynamics [13], Section V). The two strategies-priors and surrogates-are often combined (see Fig. 2); for example, most works with a surrogate model impose a policy structure and some of them use prior information to shape the initial surrogate function, before acquiring any data.
This article surveys the literature along these three axes: priors on policy structure and parameters (see Section III), models of expected return (see Section IV), and models of dynamics (see Section V). Section VI lists the few noteworthy approaches for MDPS that do not fit well into the previous sections. Finally, Section VII sketches the challenges of the field and Section VIII new frontier of robot learning?) and we think it is the right time to summarize the recent efforts in this direction: while there have been survey articles on PS in the past (in particular [10], [12]), there have been many exciting developments in the last years (e.g., 50% of the papers cited in our survey have been published between 2013 and 2018). Moreover, our survey focuses on PS algorithms that have the explicit goal of minimizing the interaction time as much as possible (and not RL or PS algorithms in general), whereas previous surveys had a broader region of interest. Consequently, we can be more thorough in our review and explain the algorithms in more detail. proposes a few "precepts" and recommendations to guide future work in this field.

II. PROBLEM FORMULATION
We model the robots as discrete-time dynamical systems that can be described by transition probabilities of the form where the robot is at state x t ∈ R E at time t, takes control input u t ∈ R F , and ends up at state x t+1 at time t + 1. If we assume deterministic dynamics and Gaussian system noise, this equation is often written as Here, w is i.i.d. Gaussian system noise, and f is a function that describes the unknown transition dynamics. We assume that the system is controlled through a parameterized policy π(u|x, t, θ) that is followed for T steps (θ are the parameters of the policy). Throughout the article, we adopt the episode-based, fixed time-horizon formulations for clarity and pedagogical reasons, but also because most of the MDPS approaches use this formulation.
In the general case, π(u|x, t, θ) outputs a distribution (e.g., a Gaussian) that is sampled in order to get the action to apply; i.e., we have stochastic policies. Most algorithms utilize policies that are not time-dependent (i.e., they drop t), but we include it here for completeness. Several algorithms use deterministic policies; a deterministic policy means that π(u|x, t, θ) ⇒ u = π(x, t|θ).
When following a particular policy for T time-steps from an initial state distribution p(x 0 ), the system's states and actions jointly form trajectories τ = (x 0 , u 0 , x 1 , u 1 , . . . , x T ), which are often also called rollouts or paths. We assume that a scalar performance system exists, R(τ ), that evaluates the performance of the system given a trajectory τ . This long-term reward (or return) is defined as the sum of the immediate rewards Algorithm 1: Generic Policy Search Algorithm.
1: Apply initialization strategy using INITSTRATEGY 2: Collect data, D 0 , with COLLECTSTRATEGY 3: for n = 1 → N iter do 4: Learn models using MODELSTRATEGY and D n−1 5: Calculate θ n+1 using UPDATESTRATEGY 6: Apply policy π θ n+1 on the system 7: Collect data, D n , with COLLECTSTRATEGY 8: end for 10: return π θ * = SELECTBESTPOLICYSTRATEGY along the trajectory τ where r t+1 = r(x t , u t , x t+1 ) ∈ R is the immediate reward of being in state x t at time t, taking the action u t and reaching the state x t+1 at time t + 1. We define the expected return J(θ) as a function of the policy parameters where P (τ |θ) is the distribution over trajectories τ for any given policy parameters θ applied on the actual system P (τ |θ) The objective of a PS algorithm is to find the parameters θ * that maximize the expected return J(θ) when following the policy π θ * θ * = arg max θ J(θ).
Most PS algorithms can be described with a generic algorithm (Algorithm 1) and they: 1) start with an initialization strategy (INITSTRATEGY), for instance, using random actions, and 2) collect data from the robot (COLLECTSTRATEGY), for instance, the states at each discrete time-steps or the reward at the end of the episode; they, then 3) enter a loop (for N iter iterations) that alternates between learning one or more models (MODELSTRATEGY) with the data acquired so far, and selecting the next policy π θ n+1 to try on the robot (UPDATESTRATEGY). Finally, they return the "optimal" policy using SELECTBESTPOLICYSTRATEGY.
This generic outline allows us to describe direct (e.g., policy gradient algorithms [22]), surrogate-based (e.g., Bayesian optimization (BO) [20]) and model-based PS algorithms, where each algorithm implements in a different way each of INITSTRATEGY, COLLECTSTRATEGY, MODELSTRATEGY, and UPDATESTRATEGY. We will also see that in this outline, we can also fit PS algorithms that utilize priors; coming from simulators, demonstrations or any other source.
To better understand how PS is performed, let us use a gradient-free optimizer (UPDATESTRATEGY) and learn directly Algorithm 2: Gradient-Free Direct Policy Search Algorithm.
1: procedure INITSTRATEGY 2: Select θ 1 randomly 3: end procedure 4: procedure COLLECTSTRATEGY 5: Collect samples of the form (θ, N i R(τ ) i N ) = (θ,J θ ) by running policy π θ N times. 6: end procedure on the system (i.e., MODELSTRATEGY = ∅). This type of algorithm falls in the category of model-free or direct PS algorithms [1], [23]. INITSTRATEGY can be defined as randomly choosing some policy parameters, θ 1 (Algorithm 2), and COL-LECTSTRATEGY collects samples of the form (θ, ) by running N times the policy π θ . We execute the same policy multiple times because we are interested in approximating the is, then, used as the value for the sample θ in a regular optimization loop that tries to maximize it (i.e., the UPDATESTRATEGY is optimizer-dependent).
This straightforward approach to PS typically requires a large amount of interaction time with the system to find a highperforming solution [1]. Many approaches have been suggested to improve the sample efficiency of model-free approaches (e.g., [4], [22], [24]- [30]). Nevertheless, the objective of the present article is to describe algorithms that require several orders of magnitude less interaction time by leveraging priors and models.

III. USING PRIORS ON THE POLICY PARAMETERS/REPRESENTATION
When designing the policy π(u|x, t, θ), the key design choices are what the space of θ is, and how it maps states to actions. This design is guided by a tradeoff between having a representation that is expressive, and one that provides a space that is efficiently searchable.
Expressiveness can be defined in terms of the optimal policy π * ζ . For a given task ζ, there is theoretically always at least one optimal policy π * ζ . Here, we drop θ to express that we do not mean a specific representation parameterized by θ. Rather π * ζ emphasizes that there is some policy (with some representation, perhaps unknown to us) that cannot be outperformed by any other policy (whatever its representation). We use J ζ (π * ζ ) to denote this highest possible expected reward. A parameterized policy π θ should be expressive enough to represent this optimal policy π * ζ (or at least come close), i.e., where δ is some acceptable margin of suboptimality. Note that absolute optimality is rarely required in robotics; in many everyday applications, small tracking errors may be acceptable, and the quadratic command cost does not need to be at the absolute minimum.
On the other hand, the policy representation should be such that it is easy (or at least feasible) to find θ * , i.e., it should be efficiently searchable. 4 In general, smaller values of dim(θ) lead to more efficiently searchable spaces.
In the following sections, we describe several common policy representations, which make different tradeoffs between expressiveness and being efficiently searchable, and several common strategies to improve the generality and convergence of PS algorithms.

A. Hand-Designed Policies
One approach to reducing the policy parameter space is to hand-tailor it to the task ζ to be solved. In [31], for instance, a policy for ball acquisition is designed. The resulting policy only has only four parameters, i.e., dim(θ) is 4. This low-dimensional policy parameter space is easily searched, and only 672 trials are required to optimize the policy. Thus, prior knowledge is used to find a compact representation, and PS is used to find the optimal θ * for this representation.
One disadvantage of limiting dim(θ) to a very low dimensionality is that δ may become quite large, and we have no estimate of how much more the reward could have been optimized with a more expressive policy representation. Another disadvantage is that the representation is very specific to the task ζ for which it was designed. Thus, such a policy cannot be reused to learn other tasks. It, then, greatly limits the transfer learning capabilities of the approaches, since the learned policy can hardly be reused for any other task.

B. Policies as Function Approximators
Ideally, our policy representation Θ is expressive enough so that we can apply it to many different tasks, i.e., arg min i.e., over a set of tasks, we minimize the sum of differences between the theoretically optimal policy π * for each task, and the optimal policy given the representation π θ for each task. 5 A few examples of such generally applicable policy representations are linear policies, radial basis function networks, and neural networks (NN). These more general policies can be used for many tasks [12], [32]. However, prior knowledge is still required to determine the appropriate number of basis functions and their shape. Nonparametric methods partially alleviate the need to use these parameters [33], but the number of basis functions (one for each data point) may become very large and slow down learning. Again, a lower number of basis functions will usually lead to more efficient learning, but less expressive policies and, thus, potentially higher δ.
One advantage of using a function approximator is that demonstrations can often be used to determine the initial policy parameters. The initial parameters θ 1 can be obtained through supervised learning or other machine learning techniques, by providing the demonstration as training data (x i , u i ) i=1:N . This is discussed in more detail in Section III-G.
The function approximator can be used to generate a single estimate (corresponding to a first-order moment in statistics), but it can also be extended to higher order moments. Typically, extending it to second-order moments allows the system to get information about the variations that we can exploit to fulfill a task, as well as the synergies between the different policy parameters in the form of covariances. This is typically more expensive to learn-or it requires multiple demonstrations [34]-but the learned representation can typically be more expressive, facilitating adaptation and generalization.

C. Trajectory-Based Policies
Trajectory-based policy types have been widely used in the robot learning literature [35]- [39], and especially within the PS problem for robotics [39]- [41]. This type of policy is wellsuited for several typical classes of tasks in robotics, such as point-to-point movements or repetitive movements. There exist basically two types of trajectory-based policies: 1) way-point based policies [42], and 2) dynamical system based [35], [41].
One approach to encoding trajectories is to define the policy as a sequence of way-points. Roy and Thrun [42] defined the problem of motion planning as a PS problem where the parameters of the policy are the concatenated way-points, w i . They were able to define an algorithm that outperforms several baselines including dynamic programming.
Policies based on dynamical systems have been used more extensively within the robot learning literature as they combine the generality of function approximators with the advantages of dynamical systems, such as robustness toward perturbations and stability guarantees [35], [39]- [41], which are desirable properties of a robotic system.
Perhaps the most widely used trajectory-based policy type within the PS framework is dynamical movement primitives (DMPs); we can categorize them into discrete DMPs and rhythmic DMPs depending on the type of motion they are describing (point-to-point or repetitive).
Discrete DMPs are summarized in (9). The canonical system represents the movement phase s, which starts at 1, and converges to 0 over time. The transformation systems combines a spring-damper system with a function approximator f θ , which, when integrated, generates accelerationsξ. Multidimensional DMPs are achieved by coupling multiple transformation systems with one canonical system. The vector ξ typically represents the end-effector pose or the joint angles.
As the spring-damper system converges to ξ g , and s (and, thus, s f θ (s)) converges to 0, the overall system ξ is guaranteed to converge to ξ g . We have This facilitates learning, because, whatever parameterization θ of the function approximator we choose, a discrete DMP is guaranteed to converge toward a goal ξ g . Similarly, a rhythmic DMP will always generate a repetitive motion, independent of the values in θ. The movement can be made slower or faster by changing the time constant ω. Another advantage of DMPs is that only one function approximator is learned for each dimension of the DMP, and that the input of each function approximator is the phase variable s, which is always 1-D. Thus, whereas the overall DMP closes the loop on the state ξ, the part of the DMP that is learned (f θ (s)) is an open-loop system. This greatly facilitates learning, and simple black-box optimization algorithms have been shown to outperform state-of-the-art RL algorithms for such policies [43]. Approaches for learning the goal ξ g of a discrete movement have also been proposed [44]. Since the goal is constant throughout the movement, few trials are required to learn it.
The optimal parameters θ * for a certain DMP are specific to one specific task ζ. Task-parameterized (dynamical) motion primitives aim at generalizing them to variations of a task, which are described with the task parameter vector q (e.g., the 3-D pose to place an object on a table [45] or the 3-D pose of the end-effector [37]). Similar approaches can be used in contextual policies, see, e.g., [46], [47]. Learning a motion primitive that is optimal for all variations of a task (i.e., all q within a range) is much more challenging, because the curse of dimensionality applies to the task parameter vector q just as it does for the state vector x in RL. Task-parameterized representations based on the use of multiple coordinate systems have been developed to cope with this curse of dimensionality [48]. These models have only been applied to learning from demonstration applications so far.
DMPs, nevertheless, are time-dependent and, thus, can produce behaviors that are not desirable; for example, a policy that cannot adapt to perturbations after some time. Stable estimator of dynamical systems (SEDS) [35] explore how to use dynamical systems in order to define autonomous (i.e., time-independent) controllers (or policies) that are asymptotically stable. The main idea of the algorithm is to use a finite mixture of Gaussian functions as the policy,ξ = π seds (ξ), with specific properties that satisfy some stability guarantees. SEDS, however, requires demonstrated data in order to optimize the policy (i.e., data gathered from experts), although similar ideas have been used within the RL framework [32].
It is important to note that if ξ or w are not defined in joint space (i.e., the control variables), then most of the approaches assume the existence of a low-level controller that can take target accelerations, velocities, or positions (in ξ or w) and produce the appropriate low-level control commands (e.g., torques) to achieve these targets. Moreover, all the stability and convergence guarantees mentioned in this section apply solely on the behavior or policy dynamics (e.g., stability or convergence of the desired velocity profile in the end-effector space) and not on the robotic system as a whole. 6

D. Learning the Controller
If the policy generates a reference trajectory, a controller is required to map this trajectory (and the current state) to robot control commands (typically torques or joint angle velocity commands). This can be done, for instance, with a proportionalintegral-derivative controller [49], or a linear quadratic tracking controller [50]. The parameters of this controller can also be included in θ, so that both the reference trajectory and controller parameters are learned at the same time. By doing so, appropriate gains [49], [51] or forces [52] for the task can be learned together with the movement required to reproduce the task. Typically, such representation provides a way to coordinate motor commands to react to perturbations, by rejecting perturbations only in the directions that would affect task performance.

E. Learning the Policy Representation
So far we have described how the policy representation is determined with prior knowledge, and the θ of this policy is, then, optimized through PS. Another approach is to learn the policy representation and its parameters at the same time, as in NeuroEvolution of Augmenting Topologies [53]. It is even possible, in simulation, to coevolve an appropriate body morphology and policy [54], [55]. These approaches, however, require massive amounts of rollouts, and do not focus on learning in a handful of trials.

F. Hierarchical and Symbolic Policy Representations
To further generalize policies to different contexts, several approaches have been proposed. Daniel et al. [56] proposed the use of a hierarchical policy composed of a gating network and multiple subpolicies, and introducing an entropy-based constraint ensuring that the agent finds distinct solutions with different subpolicies. These subpolicies are treated as latent variables in an expectation-maximization procedure, allowing the distribution of the update information between the subpolicies. Higher layers of the hierarchy may be replaced with symbolic representations, as in [57]- [59]. A full discussion of the many approaches in this area is beyond the scope of this article.

G. Initialization With Demonstrations/Imitation Learning
An advantage of using expressive policies is that they are able to learn (close to) optimal policies for many different tasks. A downside is that such policies are also able to represent many suboptimal policies for a particular task, i.e., there will be many local minima. To ensure convergence, it is important that the initial policy parameters are close to the global optimum. In robotics, this is possible through imitation [60]- [62], i.e., the initialization of θ from a demonstrated trajectory. Starting with a θ that is close θ * greatly reduces the number of samples to find θ * , and the interplay between imitation and PS is, therefore, an important component in micro-data learning.
Initialization with demonstrations is possible if we know the general movement a robot should make to solve the task, and if we can demonstrate it, either by recording our movement, by teleoperating the robot, or by physically guiding the robot 1: procedure COLLECTSTRATEGY 2: Collect samples of the form (θ, R(τ )) 3: end procedure 4: procedure MODELSTRATEGY 5: Learn modelĴ : θ → J(θ) 6: end procedure 7: procedure UPDATESTRATEGY 8: θ n+1 = arg max θ ACQUISITIONFUNCTION(θ|Ĵ) 9: end procedure through kinesthetic teaching. Each of these modalities has some limitations. Observational learning does not take into account differences between user and robot (in terms of embodiment, kinematic, and dynamic capabilities). Dynamic or skillful tasks are difficult to demonstrate by teleoperation and kinesthetic teaching. Recording both force and position information is limited with kinesthetic teaching and observational learning.
Message 1: Using policy structures that are inspired or derived by prior knowledge about the task or the robot at hand is an effective way of creating a policy representation that is expressive enough but also efficiently searchable. If it is further combined with learning from demonstrations (or imitation learning), then it can lead to powerful approaches that are able to learn in just a handful of trials.
Recommended readings: [60], [62] IV. LEARNING MODELS OF THE EXPECTED RETURN With the appropriate policy representation (and/or initial policy parameters) chosen, the PS in Algorithm 1 is, then, executed. The most important step is determining the next parameter vector θ n+1 to test on the physical robot.
In order to choose the next parameter vector θ n+1 to test on the physical robot, a strategy is to learn a modelĴ(θ) of the expected return J(θ) (4) using the values collected during the previous episodes, and, then, choose the optimal θ n+1 according to this model. Put differently, the main concept is to optimize J(θ) by leveragingĴ(θ|R(τ |θ 1 ), . . . , R(τ |θ N )).

A. BO: Active Learning of Policy Parameters
The most representative class of algorithms that falls in this category is BO [20]. BO consists of two main components: a model of the expected return, and an acquisition function, which uses the model to define the utility of each point in the search space.
BO for PS follows the generic PS algorithm (Algorithm 1) and implements COLLECTSTRATEGY, MODELSTRATEGY, and UPDATESTRATEGY (Algorithm 3). More specifically, a surrogate model,Ĵ(θ), of the expected return is learned from the data, then the next policy to test is selected by optimizing the ACQUISITIONFUNCTION. The ACQUISITIONFUNCTION tries to intelligently exploit the model and its uncertainties in order to tradeoff exploration and exploitation.
The main axes of variation are: 1) the way INITSTRATEGY is defined (the most usual approaches are random policy parameters or random actions), 2) the type of model used to learn J, 3) which ACQUISITIONFUNCTION is used, and 4) the optimizer used to optimize the ACQUISITIONFUNCTION. [63] is the most popular choice for the model. A GP is an extension of multivariate Gaussian distribution to an infinite-dimension stochastic process for which any finite combination of dimensions will be a Gaussian distribution [63]. More precisely, it is a distribution over functions, completely specified by its mean function, m(·) and covariance function, k(·, ·) and it is computed as follows:

1) Gaussian Processes (GPs): GP regression
Assuming } is a set of observations, we can query the GP at a new input point θ * as follows: The mean and variance predictions of the GP are computed using a kernel vector k k k = k(D 1:t , θ * ), and a kernel matrix K, with 2) Acquisition Functions: We here summarizes the main idea; please see [20] and [21] for a comprehensive discussion.
1) Probability of Improvement (PI). PI defines the probability that a new test pointĴ(θ) will be better than the best observation so far θ + . When using GPs as the surrogate model, this can be analytically computed [64].
The main drawback of PI is that it basically performs pure exploitation; in practice, a slightly modified version of PI is used where a tradeoff parameter ξ is added [20]. 2) Expected Improvement (EI). The EI acquisition function is an extension of PI, where the EI (deviation) from the current maximum is calculated [20]. When using GPs as the surrogate model, EI can be analytically computed. 3) Upper Confidence Bound (UCB). The UCB acquisition function simply combines the mean and variance to test points that have a "high potential;" it works very well in practice [65]. When using GPs as the surrogate model, it is defined as UCB(θ) = μ(θ) + ασ(θ), where α is a user-specified parameter. When using UCB as the acquisition function, it might be difficult to choose α and the initial hyper-parameters of the kernel (that affect σ) as the range of J and θ plays a large role on this. The GP-UCB algorithm [20], [66] automatically adjusts α and provides some theoretical guarantees on the regret bounds of the algorithm. 4) Entropy Search (ES). The ES [65] acquisition function selects policy parameters in order to maximally reduce the uncertainty about the location of the maximum of J(θ) in each step. It quantifies this uncertainty through the entropy of the distribution over the location of the maximum, p max (θ) = P (θ ∈ arg min θ J(θ)). Henning and Schuler [65] performed a thorough experimental analysis and concluded that EI can perform better on artificial objective functions than PI and UCB, but more recent experiments on gait learning on a physical robot suggested that UCB can outperform EI in real situations [67]. In most cases, ES outperforms all other acquisition functions at a bigger computation cost [65].
Martinez-Cantin et al. [68] were among the first to use BO as a PS algorithm; in particular, their approach was able to learn a policy composed of way-points in order to control a mobile robot that had to navigate in an uncertain environment. Since BO is not modeling the dynamics of the system/robot, it can be effective for learning policies for robots with complex (e.g., locomotion tasks, because of the nonlinearity created by the contacts) or high-dimensional dynamics. For instance, BO was successfully used to learn policies for a quadruped robot [69] (around 100 trials with a well-chosen 15-dimensional policy space), a small biped "compass robot" [67] (around 100 trials with a finite state automata policy), and a pocket-sized, vibrating soft tensegrity robot [70] (around 30 trials with directly controlling the motors). In all of these cases, BO was at least an order of magnitude more data-efficient than competing methods.
Unfortunately, BO scales badly with respect to the dimensionality of the policy space because modeling the objective function (i.e., the expected return) becomes exponentially harder when the dimension increases [71]. This is why all the aforementioned studies employed low-dimensional policy spaces and very well chosen policy structures (i.e., they all use a strong prior on the policy structure). Scaling up BO is, however, an active field of research and various promising approaches (e.g., random embeddings [72] and additive models [73]- [75]) could be applied to robotics in the future. Combining stochastic optimization with learned local models of the expected return can be an alternative to BO and could scale much better with respect to the policy dimensions [30].

B. BO With Priors: Using Non-Zero Mean Functions as a Starting Point for the Search Process
One of the most interesting features of BO is that it can leverage priors (e.g., from simulation or from previous tasks) to accelerate learning on the actual task. Perhaps the most representative algorithm in this area is the "intelligent trial and error" (IT&E) algorithm [15]. IT&E first uses MAP-Elites [15], an evolutionary illumination [76], [77] (also known as quality-diversity [78]) algorithm, to create a repertoire of about 15 000 high-performing policies and stores them in a low-dimensional map (e.g., 6-D whereas the policy space is 36-D). When the robot needs to adapt, a BO algorithm searches for the best policy in the low-dimensional map and uses the reward stored in the map as the mean function of a GP. This algorithm allowed a six-legged walking robot to adapt to several damage conditions (e.g., a missing or a shortened leg) in less than 2 min (less than a dozen of trials), whereas it used a simulator of the intact robot to generate the prior.
1) GP With Priors: Assuming D 1:t = {R(τ |θ 1 ), . . ., R(τ |θ t )} is a set of observations and R m (θ) being the reward according to the prior (the map), we only need to modify (13) to use non-zero mean function The formulation above allows us to combine observations from the prior and the real-world smoothly. In areas where realworld data are available, the prior's prediction will be corrected to match the real-world ones. On the contrary, in areas far from real-world data, the predictions resort to the prior function [15], [79], [80].
Following a similar line of thought but implemented differently, a few recent works [81], [82] used a simulator to learn the kernel function of a GP, instead of utilizing it to create a mean function like in IT&E [15]. In particular, Antonova et al. [81] used domain knowledge for bipedal robots (i.e., determinants of gait (DoG) [83]) to produce a kernel that encodes the differences in walking gaits rather than the Euclidean distance of the policy parameters. In short, for each controller parameter θ, a score sc(θ) is computed by summing the five DoG and the kernel k(·, ·) is defined as k(θ i , θ j ) = k(sc(θ i ), sc(θ j )). This approach outperformed both traditional BO and state-of-the-art black-box optimizers (covariance matrix adaptation evolution strategies; [84]). Moreover, in a follow-up work [82], Antonova et al. used NNs to model this kernel instead of hand-specifying it. Their evaluation shows that the learned kernels perform almost as good as hand-tuned ones and outperform traditional BO. Finally, in this article, they were able to make a physical humanoid robot (ATRIAS) walk in a handful of trials.
A similar but more general idea (i.e., no real assumption about the underlying system) was introduced by Wilson et al. [85]. They proposed a behavior-based kernel (BBK) that utilizes trajectory data to compare policies, instead of using the distance in parameters (as is usually done). More specifically, they define the behavior of a policy to be the associated trajectory density P (τ |θ) and the kernel k(·, ·) is defined as k(θ i , θ j ) = exp (−α · D(θ i , θ j )), where D(θ i , θ j ) is defined as a sum of kullback-leibler (KL)-divergences between the trajectory densities of different policies. Their approach was able to efficiently learn on several benchmarks; e.g., it required on average less than 20 episodes on the mountain car, acrobot, and cartpole swing-up tasks. One could argue that this approach does not utilize any prior information, but rather creates it on the fly; nevertheless, the evaluation was only performed with low-dimensional and well-chosen policy spaces.
Wilson et al. [85] proposed to learn models of the dynamics and the immediate reward to compute an approximate mean function of the GP, which is, then, used in a traditional BO procedure. They also combine this idea with the BBK kernel and follow a regular BO procedure where at each iteration they recompute the mean function of the GP with the newly learned models. Although, their approach successfully learned several tasks in less than ten episodes (e.g., mountain car, cartpole swing-up), there is an issue that might not be visible at first sight: the authors combine model learning, which scales badly with the state/action space dimensionality (see Section V), with BO, which scales badly with the dimensionality of the policy space. As such, their approach can only work with relatively small state/action spaces and small policy spaces. Using priors on the dynamics (see Section V-B) and recent improvements on BO (see Section IV-A) could make their approach more practical.
Lober et al. [86] used a BO procedure that selects parameterizations of a quadratic programming (QP)-based whole body controller [38], [87] in order to control a humanoid robot. In particular, they formulate a policy that includes the QP-based controller (that contains a model of the system and an optimizer) and is parameterized by way-points (and/or switching times). Their approach was able to allow an iCub robot to move a heavy object while maintaining body balance and avoid collisions [86], [88].
2) Multiple Information Sources: Instead of using the simulator to precompute priors, Marco et al. [89] proposed an approach that has the ability to automatically decide whether it will gain crucial information from a real sample or it can use the simulator that is cheaper. More specifically, they present a BO algorithm for multiple information sources. Their approach relies on ES (see Section IV-A) and they use entropy to measure the information content of simulations and real experiments. Since this is an appropriate unit of measure for the utility of both sources, the algorithm is able to compare physically meaningful quantities in the same units, and tradeoff accuracy for cost. As a result, the algorithm can automatically decide whether to evaluate cheap, but inaccurate simulations or perform expensive and precise real experiments. They applied their method, called multifidelity entropy search (MF-ES), to fine-tune the policy of a cart-pole system and showed that their approach can speed up the optimization process significantly compared to standard BO.
Pautrat et al. [16] also recently proposed to combine BO with multiple information sources (or priors). They define a new ACQUISITIONFUNCTION function for BO, which they call most likely expected improvement (MLEI). MLEI attempts to have the right balance between the likelihood of the priors and the potential for high-performing solutions. In other words, a good EI according to an unlikely model should be ignored; conversely, a likely model with a low EI might be too pessimistic ("nothing works") and not helpful. A model that is "likely enough" and lets us expect some good improvement might be the most helpful to find the maximum of the objective function. The MLEI acquisition function is defined as follows: where P i , i = 1 . . . m is the set of available priors [where each P i is defined similarly to R m in (14)]. They evaluated their approach in a transfer learning scenario with a simulated arm and in a damage recovery one with both a simulated and a physical hexapod robot. Their approach demonstrates improved performance relative to random trials or a hand-chosen prior (when that prior does not correspond to the new task). Interestingly, this method also is able to outperform the real prior in some circumstances.
3) Safety-Aware Approaches: Another interesting direction of research is using variants of BO for safety-aware learning; that is, learning that actively tries to avoid regions that might cause harm to the robot. Papaspyros et al. [90] proposed an extension of IT&E that safely tradesoff between exploration and exploitation in a damage recovery scenario. To achieve this, 1) they generate, through MAP-Elites, a diverse archive of estimations concerning performance and safety criteria and 2) they use this as prior knowledge in a constrained BO [91] procedure that guides the search toward a compensatory behavior and with respect to the safety beliefs. Their algorithm, sIT&E, allowed a simulated damaged iCub to crawl again safely.
Similarly, Berkenkamp et al. [92] introduced SafeOpt, a BO procedure to automatically tune controller parameters by trading-off between exploration and exploitation only within a safe zone of the search space. Their approach requires minimal knowledge, such as an initial, not optimal, safe controller to bootstrap the search.
This allowed a quadrotor vehicle to safely improve its performance over the initial policy.
Message 2: BO is an active learning framework for micro-data RL that is effective when using uncertainty-based models and when there exists some prior on the structure of the policy or on the expected return. However, BO is limited to low-dimensional policy spaces.

V. LEARNING MODELS OF THE DYNAMICS
Instead of learning a model of the expected long-term reward (see Section IV-A), one can also learn a model of the dynamics of the robot. By repeatedly querying this surrogate model, it is, then, possible to make a prediction of the expected return. This idea leads to model-based PS algorithms [10], [93], in which the trajectory data are used to learn the dynamics model, then PS is performed on the model [94], [95].

A. Model-Based PS: Alternating Between Updating the Model and Learning a Policy in the Model
Let us consider that the actual dynamics f (and consequently the transition probabilities) are approximated by a modelf and the immediate reward function r is approximated by a modelr. As such, in model-based PS, we are alternating between learning the models (f andr) and maximizing the expected long-term reward on the model whereP This iterative scheme can be seen as follows: Algorithm 4: Model-Based Policy Search. 1: procedure COLLECTSTRATEGY 2: Collect samples of the form (x t , u t , r t+1 ) 3: end procedure 4: procedure MODELSTRATEGY 5: Learn modelf : (x t , u t ) → x t+1 6: Learn modelr : (x t , u t , x t+1 ) → r t+1 7: end procedure 8: procedure UPDATESTRATEGY 9: θ n+1 = arg max θĴ (θ|D n ) 10: end procedure where θ 0 is randomly determined or initialized to some value, D 0 = ∅ andĴ(θ|D) means calculatingĴ(θ) once the modelsf andr are learned using the dataset of trajectories and rewards D.
Model-based PS follows the generic PS algorithm (Algorithm 1) and implements COLLECTSTRATEGY, MODELSTRAT-EGY, and UPDATESTRATEGY (Algorithm 4). The main axes of variation are: 1) the way INITSTRATEGY is defined (the most usual approaches are random policy parameters or random actions), 2) the type of models used to learnf andr, 3) the optimizer used to optimizeĴ(θ|D n ), and 4) how are the longterm predictions, given the models, performed (i.e., how (16) is calculated or approximated).
Model-based PS algorithms are usually more data-efficient than both direct and surrogate-based PS methods as they do not depend much on the dimensionality of the policy space. On the other hand, since they are modeling the transition dynamics, practical algorithms are available only for relative small stateaction spaces [10], [93].
1) Model Learning: There exist many approaches to learn the modelsf andr (for model-based PS) in the literature [9], [96], [97]. Most algorithms assume a known reward function; otherwise they usually use the same technique to learn both models. We can categorize the learned models in deterministic (e.g., NNs or linear regression) and probabilistic ones (e.g., GPs).
Probabilistic models usually rely on Bayesian methods and are typically nonparametric, whereas deterministic models are typically parametric. Probabilistic models are usually more effective than deterministic models in model-based PS [10], [98] because they provide uncertainty information that can be incorporated into the long-term predictions, thus giving the capability to the optimizer to find more robust controllers (and not over-exploit the model biases). Black-DROPS [99] and PILCO [100] both utilize GPs to greatly reduce the interaction time to solve several tasks, although Black-DROPS is not tied to them and any deterministic or probabilistic model can be used.
The model-based policy gradients with parameter-based exploration algorithm [96] suggested to directly estimate the transition probabilities p(x t+1 |x t , u t ) using least-squares conditional density estimation [101], instead of learning the modelf . This formulation allowed to bypass some drawbacks of GPs such as computation speed and smoothness assumption (although choosing appropriate kernels in the GPs can produce nonsmooth predictions).
Another way of learning models of the dynamics is to use local linear models [97], [102], [103]; i.e., models that are trained on and are only correct in the regions where one controller/policy can drive the system. Guided PS (GPS) with unknown dynamics utilizes this scheme and is able to learn efficiently even in high-dimensional states and discontinuous dynamics, like 2-D walking and peg-in-the-hole tasks [97], [102] and even dexterous manipulation tasks [103].
There has, also, recently been some work on using Bayesian NNs (BNNs) [104] to improve the scaling of model-based PS algorithms [105], [106]. Compared to GPs, BNNs scale much better with the number of samples. Nevertheless, BNNs require more tedious hyper-parameter optimization and there is no established, intuitive way to include prior knowledge (apart from the structure). A combination of ensembles and probabilistic NNs has been recently proposed [107] for learning probabilistic dynamics models of higher dimensional systems; for example, state-of-the-art performance was obtained in controlling the half-cheetah benchmark [108] by combining these models with model-predictive control (MPC). Recent works showcase that using BNNs with stochastic inputs (and the appropriate PS procedure) is beneficial when learning in scenarios with multimodality and heteroskedasticity [109]; traditional model learning approaches (e.g., GPs) fail to properly model these scenarios. Moreover, decomposing aleatoric (i.e., inherent uncertainty of the underlying system) and epistemic (i.e., uncertainty due to limited data) uncertainties in BNNs (with latent input variables) can provide useful information on which points to sample next [110].
Finally, when performing model-based PS under partial observability, different model learning techniques should be used. One interesting idea is to optimize the model with the explicit goal of explaining the already observed trajectories instead of focusing on the step-by-step predictions. Doerr et al. [111] recently proposed a principled approach to incorporate these ideas into GP modeling and were able to outperform other robust models in long-term predictions and showcase improved performance for model-based PS on a real robot with noise and latencies.
2) Long-Term Predictions: Traditionally, we would categorize the model-based PS algorithms in those that perform stochastic long-term predictions by means of samplings and those that perform deterministic long-term predictions by deterministic inference techniques [10]. Recently, an alternative way of computing the expected long-term reward was introduced by [99] (Policy Evaluation as a Noisy Observation), where the trajectory generation is combined with the optimization process in order to achieve high-quality predictions with fewer Monte-Carlo rollouts.
This is basically sampling the distribution over trajectories, P (τ |θ), which is feasible since the sampling is performed with the models. When applying the same policy (i.e., a policy with the same parameters θ), the trajectories τ (and consequently r) can be different (i.e., stochastic) because (of at least one of the following): 1) the policy is stochastic; if the policy is deterministic, then u t = π θ (x t , t); 2) the models (f and/or r) are probabilistic; and 3) of the initial state is a probability distribution, p(x 0 ).

Monte-Carlo & PEGASUS policy evaluation:
Once we know how to generate trajectories given some policy parameters, we need to define the way to evaluate the performance of these policy parameters. Perhaps the most straightforward way of computing the expected log-term reward of some policy parameters is to generate m trajectories with the same policy along with their long-term costs and, then, compute the average (i.e., One more efficient way of computing the expected long-term reward with stochastic trajectories is the PEGASUS sampling procedure [112]. In the PEGASUS sampling procedure, the random seeds for each time step are fixed. As a result, repeating the same experiment (i.e., the same sequence of control inputs and the same initial state) would result into exactly the same trajectories. This significantly reduces the sampling variance compared to pure Monte-Carlo sampling and can be shown that optimizing this semi-stochastic version of the model is equivalent to optimizing the actual model.
The advantages of the sampling-based policy evaluations schemes are that each rollout can be performed in parallel and that they require much less implementation effort than the deterministic long-term predictions (see Section V-A2b). Nevertheless, these sampling-based procedures can experience big variances in the predictions that may negatively affect the optimization process. Kupcsik et al. [46] showed that when using enough sample trajectories, better approximations of the expected return can be obtained than the ones of deterministic long-term predictions (see Section V-A2b); moreover, computation time can be greatly reduced by exploiting the parallelization capabilities of modern GPUs. Another recent work [107] also strongly justifies the use of sampling-based policy evaluations over deterministic inference methods (especially in higher dimensional systems).
Probabilistic Inference for Particle-Based PS (PIPPS): Recently, Parmas et al. [98] proposed the PIPPS algorithm, which effectively combines the Reparameterization gradients (RP) and the Likelihood ratio gradients (LR); they call them total propagation (TP). Their paper showcases that LR gradients (and their combined TP gradients) do not suffer from the curse of chaos (or exploding gradients), whereas RP gradients require a very large number of rollouts to accurately estimate the gradients, even for simple problems.

b) Deterministic Long-Term Predictions:
Instead of sampling trajectories τ , the probability distributionP (τ |θ) can be computed with deterministic approximations, such as linearization [113], sigma-point methods [114], or moment matching [9]. All these inference methods attempt to approximate the original distribution with a Gaussian.
Computingp(x t+1 ) corresponds to solving the integral This integral can be computed analytically only if the transition dynamicsf are linear (in that casep(x t+1 ) is Gaussian). This is rarely the case and as such, approximate inference techniques are used. Usually, we approximatep(x t+1 ) as a Gaussian; this can be done either by linearization [113], sigma-point methods [114] or moment matching [9]. The PILCO algorithm [100] uses moment matching, which is the best unimodal approximation of the predictive distribution in the sense that it minimizes the KL-divergence between the true predictive distribution and the unimodal approximation [10]. One big advantage of using deterministic inference techniques for long-term predictions is the low-variance they exhibit in the predictions. In addition, using these inference techniques allows for analytic gradient computation and as such we can exploit efficient gradient-based optimization. However, each of these inference techniques has its own disadvantages; for example, exact moments (for moment matching) can be computed only in special cases since the required integrals might be intractable, which limits the overall approach (e.g., PILCO requires that the reward function is known and differentiable).
The PILCO algorithm [9] uses this type of long-term predictions and it was the first algorithm that showed remarkable data-efficiency on several benchmark tasks (e.g., less than 20 s of interaction time to solve the cart-pole swing-up task) [100]. It was also able to learn on a physical low-cost manipulator [115] and simulated walking tasks [116] among the many successful applications of the algorithm [9]. c) Policy Evaluation as a Noisy Observation: This approach [99] exploits the implicit averaging property [117]- [119] of population, rank-based optimizers, like CMA-ES [120], in order to perform sampling-based evaluation of the trajectories efficiently (i.e., reducing the computation time of the PS on the model). The key idea is that when using this type of optimizers, the problem can be transformed into a noisy optimization one, thus, there is no need to (fully) compute the expected longterm reward, as this expectation can be implicitly computed by the optimizer. Similar ideas have been previously explored for model-free PS [121].
In more detail, instead of performing deterministic long-term predictions, like PILCO, or Monte-Carlo evaluation, like PE-GASUS, Black-DROPS stochastically generates trajectories, but considers that each of these trajectories (or rollouts) is a measurement of a function G(θ) that is the actual function J(θ) perturbed by a noise N (θ), that is, G(θ) =Ĵ(θ) + N (θ).

It is easy to verify that maximizing E[G(θ)] is equivalent to maximizingĴ(θ), when E[N (θ)] = constant.
Implicit averaging and noisy functions: Seeing the maximization ofĴ(θ) as the optimization of a noisy function allows to maximize it without computing or estimating it explicitly. The Black-DROPS algorithm utilizes a recent variant of CMA-ES (i.e., one of the most successful algorithms for optimizing noisy and black-box functions [117], [122], [123]) that combines random perturbations with re-evaluation for uncertainty handling [122] along with restart strategies for better exploration [124].
While Black-DROPS has the same data-efficiency as PILCO, it has the added benefit of being able to exploit multicore architectures, thus, greatly reducing the computation time [99]. Similar to most Monte-Carlo methods (like GP-REPS [46]), Black-DROPS is a purely black-box model-based PS algorithm; i.e., one can swap the model types, reward functions and/or initialization procedure with minimal effort. This is an important feature as it allows us to more easily exploit good sources of prior information [17]. Black-DROPS was able to learn in less than 20 s of interaction time to solve the cartpole swing-up task as well as to control a physical 4-DOF physical manipulator in less than 5-6 episodes.

B. Using Priors on the Dynamics
Reducing the interaction time in model-based PS can be achieved by using priors on the models [17], [79], [125]- [129]; i.e., starting with an initial guess of the dynamics (and/or the reward function) and, then, learning the residual model. This type of algorithm follows the general model-based PS framework (Algorithm 4) and usually implement different types of INITSTRATEGY. Notably, the most successful approaches rely on GPs to model the dynamics, as priors can be very elegantly incorporated.

1) GPs With Priors for Dynamical Models: Assuming
. ., f(x t )} is a set of observations,x t = (x t , u t ) ∈ R E+F and M (x) being the simulator function (i.e., the initial guess of the dynamics), we can query the GP at a new input pointx * similar to (14) μ( We usually need E independent GPs; one for each output dimension [99], [100]. A few approaches [125], [130] use simple analytic and fast simulators to create a GP prior of the dynamics (and assume the reward function to be known). PILCO with priors [127] uses simulated data (from running PILCO in the simulator) to create a GP prior for the dynamics and, then, performs PS with PILCO. It was able to increase the data-efficiency of PILCO in a real inverted pendulum using a very simple model as a prior. A similar approach, PI-REM [128], utilizes analytic equations for the dynamics prior and tries to actively bring the real trials as close as possible to the simulated ones (i.e., reference trajectory) using a slightly modified PILCO PS procedure. PI-REM was also able to increase the data-efficiency of PILCO in a real inverted pendulum (with variable stiffness actuators) using a simple model as a prior.
Black-DROPS with priors [17] proposes a new GP learning scheme that combines model identification and nonparametric model learning (called GP-MI) and, then, performs PS with Black-DROPS. The main idea of GP-MI is to use simulators with tunable parameters, i.e., mean functions of the form M (x, φ M ) where each vector φ M ∈ R n M corresponds to a different prior model of the system (e.g., different lengths of links). Searching for the φ M that best matches the observations can be seen as a model identification procedure, which could be solved via minimizing the mean squared error; nevertheless, the authors formulate it in a way so that they can exploit the GP framework to jointly optimize for the kernel hyperparameters and the mean parameters, which allows the modeling procedure to balance between nonparametric and parametric modeling.
Black-DROPS with GP-MI was able to robustly learn controllers for a pendubot swing-up task [131] even when the priors were misleading. More precisely, it was able to outperform Black-DROPS, PILCO, PILCO with priors, Black-DROPS with fixed priors (i.e., this should be similar to PI-REM) , and IT&E. Moreover, Black-DROPS with GP-MI was able to find highperforming walking policies for a physical damaged hexapod robot (48-dimensional state and 18-dimensional action space) in less than 1 min of interaction time and outperformed IT&E that excels in this setting [15], [17].
Following a similar rationale, VGMI [132], uses a BO procedure to find the simulator's mechanical parameters so as to match the real-world trajectories (i.e., it performs model identification) and, then, performs PS on the updated simulator. In particular, VGMI was able to learn policies for a physical dual-arm collaborative task and outperformed PILCO.
Finally, an approach that splits the self-modeling process from the PS is presented in [133]. The authors were among the first ones to combine a self-modeling procedure (close to model identification [134]) with PS. The self-modeling part of their approach consists of three steps: 1) action executing and data collection, 2) synthesization of 15 candidate self-models that explain the sensory data, and 3) active selection of the action that will elicit the most information from the robot. After a few cycles of these steps (i.e., around 15), the most accurate model is selected and PS is performed to produce a desired behavior. Their approach was able to control in less than 20 episodes a four-legged robot and it was also able to adapt to damages in a few trials (by rerunning the self-modeling procedure).

Message 3:
Model-based PS algorithms are the most data-efficient algorithms, especially when they take into account the uncertainty of the model. While they typically suffer from the curse of dimensionality (state/action space), endowing them with prior knowledge on the dynamics can reduce their interaction time requirements even when learning with high-dimensional or complicated systems. The main challenge in this direction is to overcome the computational complexity of the approaches.

A. Guided Policy Search
GPS with unknown dynamics [97], [102] is a somewhat hybrid approach that combines local trajectory optimization (that happens directly on the real system), learning local models of the dynamics (see Section V-A1), and indirect PS where it attempts to approximate the local controllers with one big NN policy (using supervised learning). In more detail, GPS consists of two loops: an outer loop that executes the local linear-Gaussian policies on the real system, records data, and fits the dynamics models and an inner loop where it alternates between optimizing the local linear-Gaussian policies (using trajectory optimization and the fitted dynamics models) and optimizing the global policy to match all the local policies (via supervised learning and without utilizing the learned models) [102].
The results of GPS show that it is less data-efficient than model-based PS approaches, but more data-efficient than traditional direct PS. Moreover, GPS is able to handle bigger state-action spaces (i.e., it has also been used with image observations [102]) than traditional model-based PS approaches as it reduces the final policy optimization step in a supervised one that can be efficiently tackled with all the recent deep learning methods [2]. GPS was able to learn in less than 100 episodes even in high-dimensional states and discontinuous dynamics like 2-D walking, peg-in-the-hole task, and controlling an octopus robot [97], [102] among the many successful applications of the algorithm [135], [136].

B. Transferability Approaches
The main hypothesis of the transferability approach [137], [138] is that physics simulators are accurate for some policies, e.g., static gaits, and inaccurate for some others, e.g., highly dynamic gaits. As a consequence, it is possible to learn in simulation if the search is constrained to policies that are simulated accurately. As no simulator currently comes with an estimate of its accuracy, the key idea of the transferability approach is to learn a model of a transferability function, which predicts the accuracy of a simulator given policy parameters or a trajectory in simulation. This function is often easier to learn than the expected return because this is essentially a classification problem (instead of regression). In addition, small errors in the model have often little consequences, because the search is mainly driven by the expected return in simulation (and not by the transferability optimization).
The resulting learning process requires only a handful trials on the physical robot (in most of the experiments, less than 25); however, the main drawback is that it can only find policies that perform similarly in simulation and in reality (e.g., static gaits versus highly dynamic gaits). These type of algorithms were able to efficiently learn policies for mobile robots that have to navigate in mazes [137] (15 trials on the robot), for a walking quadruped robot [137], [139] (about ten trials) and for a 6-legged robot that had to learn how to walk in spite of a damaged leg without updating the simulator [138] (25 trials). Similar ideas were recently developed for humanoid robots with QP-based controllers [38].

C. Simulation-to-Reality and Meta-Learning Approaches
The main idea behind meta-learning and SimToReal approaches is to find a policy that is robust to a distribution of tasks (or environments). SimToReal approaches exploit parameterized simulators in order to learn a policy that can effectively transfer on the real system. SimToReal algorithms can be categorized into ones that find policies that are robust: 1) to visual differences [140]- [143] (domain randomization), and 2) to different dynamics properties [144]- [146] (dynamics randomization).
James et al. [141] used a rather simple controller, sample different goal targets, and visual conditions (e.g., lighting, textures) and collect 1 million state-action trajectories of completing different goals. Once this dataset is collected, a convolutional NN, which will later serve as the policy, is trained in a supervised manner to find a mapping between image observations and the appropriate actions to take. Finally, they deploy this policy in the real world. Astonishingly, they were able to get 100% success rate in the real-world scenarios despite the fact that their task involved contacts and anticipating dynamic effects (i.e., picking and placing objects in a basket). Peng et al. [146] used the hindsight experience replay [147] algorithm in order to maximize the expected return across a distribution of dynamics models. The dynamics parameters include masses and lengths of the links, damping and friction coefficients among others. Using their algorithm a 7-DOF manipulator learned how to push a puck on a desired location and directly transferred from simulation to reality.
However, these approaches do not provide any online adaptation capabilities; this basically means that if, for some reason, the policy does not generalize to the real-world instance, the robot cannot improve its performance. SimOpt [144] tries to close the loop by using real experience in order to find the distribution of the dynamics models to optimize on, but this type of approaches is very similar to model-based PS with priors on the dynamics models (see Section V-B). We can draw a parallel here and argue that model-based PS with probabilistic models is performing something similar to dynamics randomization. More concretely, performing PS under an uncertain model is equivalent to finding a "robust" policy that can perform well under various dynamics models: the ones defined by the mean predictions and the uncertainty of the model.
Similarly, meta-learning approaches [148]- [151] do not only try to find a robust policy but also a learning rule that can allow for fast adaptation (i.e., good performance with few gradient steps). Model-Agnostic Meta-Learning (MAML) [149] learns a good set of initial policy parameters, θ 0 , such that every task can be solved within few gradient steps. A few applications of meta-learning target fast robot adaptation with promising results [150], [151]. For example, Saemundsson et al. [151] modeled the distribution over systems using a latent embedding and model the dynamics using a global function (with GPs) conditioned on the latent embedding. They were able to learn control policies for the cartpole swing-up and the double pendulum tasks in less than 30 s of interaction time including the meta-training time. Clavera et al. [150] used MAML to train a dynamics model prior such that, when combined with recent data, this prior can be rapidly adapted to the local context. They were able to combine their dynamics model with MPC in order to control a six-legged miniature physical robot in unknown/new situations (e.g., payload or different terrains), but still required 30 min of interaction time for the meta-training process.
Message 4: Simulation-to-reality or meta-learning approaches can produce robust and adaptive policies that offer fast adaptation at test time. While they typically require expensive interaction time before the mission (e.g., in simulation), this should not be feared, as they can possibly produce the right prior for the task at hand. If they are combined with some online adaptation or model-learning [152], they can learn effectively.

A. Scalability
Most of the works we described so far have been demonstrated with simple robots and simple tasks, such as the cartpole swing-up task (4-D state space, 1-D action space) [100] or simple manipulators (4-D state space and 4-D action space) [99]. By contrast, humanoid robots have orders of magnitude larger state-action spaces; for example, the 53-DOF iCub robot [153] has a state space of more than 100 dimensions (not counting tactile and visual sensors [154]). Most of the current micro-data approaches are unable to learn with such complex robots.
On the one hand, model-based PS algorithms (see Section V-A) generalize well to new tasks (since the model does not depend on the task) and learn high-dimensional policies with little interaction time (since the PS happens within the model and not in interaction with the robot); but they do not scale well with the size of the state space: in the general case, the quantity of data to learn a good approximation of the forward model scales exponentially with the dimensionality of the state-space (this is the curse of dimensionality, see [71]). A factored state representation may provide the means to tackle such complexity, for example, by using dynamic Bayesian networks [155] to represent the forward model [156], but we are not aware of any recent work in this direction.
On the other hand, direct PS algorithms (see Sections III-G and IV) can be effective in learning control policies for highdimensional robots, because the complexity of the learning problem mostly depends on the number of parameters of the policy, and not on the dimensionality of the state-space; however, they do not generalize well to new tasks (when there is a model, it is specific to the reward) and they require a low-dimensional policy. Such a low-dimensional policy is an important, taskspecific prior that constrains what can be learnt. For example, central pattern generators can be used for rhythmic tasks such as locomotion [157], but they are unlikely to work well for a manipulation task; similarly, quadratic programming-based controllers (and in general model-based controllers) can facilitate learning whole body controllers for humanoid robots [38], [158], but they impose the control strategy and the model. In summary, model-based PS algorithms scale well with the dimensionality of the policy, but they do not scale with the dimensionality of the state space; and direct PS algorithms scale well with the dimensionality of the state space, but not with the dimensionality of the policy. None of these two approaches will perform well on every task: future work should focus on either scaling model-based PS algorithms so that they can learn in high-dimensional state spaces, or scaling direct PS algorithms so that they can use higher-dimensional policies.
The dimensionality of the sensory observations is also an important challenge for micro-data learning: to our knowledge, no approach that performs "end-to-end learning," that is, learning with a raw data stream like a camera, has the efficiency of micro-data learning. Deep RL has recently made possible to learn policies from raw pixel input [3], largely because of the prior (i.e., an architectural inductive bias) provided by convolutional networks. However, deep RL algorithms typically require a very large interaction time with the environment (e.g., 38 days of play for Atari 2600 games [3]), which is not compatible with most robotics experiments and applications. To address this challenge, a potential starting point is to use unsupervised learning to learn low-dimensional features, which can then be used as inputs for policies. Interestingly, it is possible to leverage priors to learn such state representations from raw observations in a reasonable interaction time [159], [160]. It is also possible to create forward models in image space, that is, predicting the next image knowing the current one and the actions, which would allow to design model-based PS algorithms that work with an image stream [161]- [164].

B. Priors
Evolution has endowed animals and humans with substantial prior knowledge. For instance, hatchling turtles are prewired to run toward the sea [165]; or marine iguanas are able to run and jump within moments of their birth in order to avoid being eaten by snakes. 7 These species cannot rely on online learning mechanisms for mastering these behaviors: without such priors they would simply cease to exist.
Similarly to priors obtained from nature, artificial agents or robots can learn very quickly when provided with the right priors, as we presented in Sections III, IV-B, and V-B. In other words, priors play a catalytic role in reducing the interaction time of PS methods. Thus, the following questions naturally arise (see Fig. 3): what should be innate and what should be learned? and how should the innate part be designed?
Most of the existing methodologies use task-specific priors (e.g., demonstrations). Such priors can greatly accelerate PS, but have the disadvantage of requiring an expert to provide them for all the different tasks the robots might face. More generic or task-agnostic priors (e.g., properties of the physical world) could relax these assumptions while still providing a learning speedup. Some steps have been made into identifying such task-agnostic priors for robotics, and using them for state representation [159], [166]. We believe this is an important direction that requires 7 As portrayed in the recent documentary "Planet Earth 2" from BBC. Fig. 3. Tradeoff between prior knowledge and learning: for any task, there is an infinity of combinations between the amount of prior knowledge and the amount of learning required (image based on a slide by Oliver Brock, 2017). more investigation. Meta-learning [148]- [151] is a related line of work that can provide a principled and potentially automatic way of designing priors.
Physical simulations can also be used to automatically generate priors while being a very generic tool [15], [16], [81], [82]. By essence, physical simulations can run in parallel and take advantage of faster computing hardware (from clusters of CPUs to GPUs): learning priors in simulation could be an analog of the billions of years of evolution that shaped the learning systems of all the current lifeforms.
While priors can bootstrap PS, they can also be misleading when a new task is encountered. Thus, an important research avenue is to design PS algorithms that can not only incorporate well-chosen priors, but also ignore those that are irrelevant for the current task [17]. Following this line of thought, a promising idea is to design algorithms that actively select among a variety of priors [16].

C. Generalization and Robustness
The majority of aforementioned articles are not much concerned with the generalization abilities and the robustness of the learned policy: they are designed to solve a single task, in a single context, with often little evaluation of the abilities to reject perturbations. For example, IT&E [15] focused on a repertoire of forward walking gaits for a hexapod robot on flat ground, rather than on various surfaces (e.g., incline surface or stairs) or various directions [80]; PILCO was applied for stacking a tower of foam blocks with a robotic manipulator [9], but the task remained fixed over the course of learning (e.g., the size of the cubes did not vary) and there were no external perturbations (e.g., a wind gust). Put differently, in most of the reported experiments, the algorithms are very likely to have "overfitted" the robot and the task.
This situation could appear surprising because generalization and robustness are two of the most important questions in machine learning and control theory [134]. Its source is, however, straightforward: assessing the robustness or the generalization abilities of a policy typically requires a significant additional interaction time. For example, a typical approach to measure the robustness of a control policy is to evaluate it with many different starting conditions and perturbations; a similar technique is often used to test the generalization abilities. Nevertheless, such an approach multiplies the interaction time by the number of tested conditions, which is likely to make the algorithm very quickly intractable on a real robot. In addition, this problem is amplified when the dimension of the state space increases, since there exist many more ways of perturbing a high-dimensional system than a low-dimensional one.
A potential remedy is to use policies that are intrinsically robust to some perturbations, that is, designing the policy space such that a change in the parameter space keeps the policy robust. For instance, the learning algorithm could search for a trajectory and a controller could be designed to follow it in a robust way: this corresponds to traditional trajectory optimization (or planning) in robotics [134]. This is one of the ideas behind dynamic movement primitives (see Section III), which act like "attractors" toward a trajectory of a fixed point. Similarly, it is possible to learn waypoints [86] or "repulsors" [38] to mix learning with advanced, closed-loop "whole-body" controllers. It is, also, possible to incorporate optimization layers (e.g., a QP program [167]) in an NN in order to take advantage of the structure they provide. Finally, one can learn distinct soft policies for simpler tasks and, then, compose them in order to achieve a more complicated task [168].
It is also conceivable to learn models of the generalization abilities [169], although it has, to our knowledge, never been tested with real robots. In that case, a model is trained to distinguish between behaviors (or trajectories) that are likely to overfit from those that are likely to be robust. This model can then be used in a PS algorithm (e.g., in a constrained BO scheme).
Ultimately, we would like to have robots that can learn to execute various tasks quickly under varying conditions. This means that they need to be able to generalize from their previous experience without requiring much interaction time when the task changes. Having a policy that generalizes well offers the benefit of very fast execution, as opposed to algorithms that perform planning [80] or model identification [17]. This challenge of micro-data multitask learning can be decomposed into two challenges. The first is about learning quickly to achieve different goals (i.e., only the reward function changes between tasks, for example, a robot that needs to throw a dart at different specified targets), while the second challenge is about adapting quickly to changes in the dynamics (i.e., the reward function does not change, for example, a robot that needs to cover as much distance forward as possible while walking on grass and transitioning on slippery ground).

D. Interplay Between Planning, MPC, and PS
The data-efficiency of PS algorithms like PILCO or Black-DROPS rises from the fact that they learn and use dynamical models (see Section V-A). However, if we assume that the dynamical model is known or can be learned, there is a large literature on control methods that can be used. Thus, is PS the right approach in such a case?
A fundamental controller from control theory is the linearquadratic regulator (LQR) [187], which is optimal when the dynamics are linear and the cost function is quadratic. Systems with nonlinear dynamics can be tackled with LQR by linearizing them around the current state and action, however, other approaches can be used such as differential dynamic programming [188], [189] and its simpler variant, the iterative linear-quadratic Gaussian algorithm [190] (iLQG). Generally, these methods can be used for optimal control with a large horizon lookahead, however, doing so can be computationally costly. For this reason, they are mostly employed to calculate trajectories offline; for example, GPS uses iLQG as the trajectory optimization procedure.
A way to permit online trajectory optimization is by reducing the horizon lookahead, thus, gaining in computational efficiency. This is known as MPC [11]. Using shorter horizons, MPC is no longer optimal with respect to the overall, high-level task. This means that MPC can be used for short-term tasks, such as tracking a trajectory, which can be produced offline. The advantage of MPC is that it can get feedback from the real system and replan at every step. Such a control scheme can be very effective and has, for example, recently allowed real-time whole-body control of humanoid robots [191].
Although MPC can replan at every step, it still has the disadvantage of relying on models. Models can be inaccurate or wrong (especially in the first episodes of learning), therefore, there needs to be a mechanism that corrects the mismatch. A potential solution could be to combine iterative learning control [192], [193] with MPC (e.g., see [163], [194]- [196]). MPC additionally has the disadvantage of requiring full knowledge of the system state. This problem can be mitigated by combining MPC with PS. For example, Zhang et al. [197] used MPC with full state information during training, to learn NN policies that do not require full state information (only raw observations) when deployed, and even run faster than MPC online.
Should we then learn a big NN policy for complex high-level tasks, such as a humanoid robot helping with the house chores? First, we need to consider that such complex tasks require long planning horizons. Second, as the task becomes more complex, so could potentially the policy space. Even if we do not consider memory requirements, learning such tasks from scratch would be intractable, even in simulation. One way of addressing such complexity is by decomposing the high-level task into a hierarchy of subtasks. Sampling-based planners [198], [199] could operate at the high to mid levels of the hierarchy, whereas MPC could operate at the mid to low levels. Furthermore, PS (or other algorithms for optimal control) can be used to discover primitives which themselves are used as components of a higher-level policy (e.g., see [200]) or a planning algorithm (e.g., see [80], [201]).

E. Computation Time
Micro-Data learning focuses on the desirable property of reducing the interaction time. However, most articles purposefully neglect computation time because they assume that it will be tackled automatically with faster hardware in the future. Although this is possible, it is worth investigating how different algorithms can potentially be sped up for near real-time execution with today's hardware.
For illustration, PILCO (see Section V-A) is a very successful and data-efficient algorithm, but can be very computationally expensive when the state-action or policy space dimensionality increases [85], [99] (e.g., Wilson et al. [85] reported that PILCO required three weeks of computation time for 20 episodes on a three-link planar arm task) and cannot take advantage of multicore architectures. Black-DROPS and Black-DROPS with GP-MI (see Section V-B) can greatly reduce the interaction time and take advantage of multicore architectures, but they still require a considerable amount of computation time (e.g., Black-DROPS with GP-MI required 24 h on a modern 16-core computer for 26 episodes of the pendubot task [17]). Both approaches use GP models, which have a complexity that is quadratic to the number of points when queried; this is clearly inefficient when millions of such GP queries (e.g., Black-DROPS performs around 64M [99]) are performed in each episode.
On the other hand, IT&E [15] and "robust policies" (e.g., see [146], [185], [181], [186]) can practically run in real time because the prior is precomputed offline. This "recipe" is shared by recent meta-learning methodologies, such as [149], that aim to learn an expressive policy that can be optimized online using a single gradient update.
This does not mean that the offline precomputation time should not be optimized. Algorithms such as IT&E or the work in [146] use a form of directed exploration to create such a prior. If, for example, random search were used, it would probably need orders of magnitude more computation time to create a prior of the same quality.

VIII. CONCLUSION
Thanks to recent advances in priors, policy representations, reward modeling, and dynamical models, it is now possible to learn policies on robots in a few minutes of interaction time. These micro-data learning algorithms considerably expand the usefulness of learning on robots: with these algorithms, we can envision robots that adapt "in front of our eyes." These algorithms, nonetheless, face critical challenges, most notably to scale-up simultaneously to high-dimensional state spaces and high-dimensional policy spaces.
As guidelines for future work in the field, we propose five precepts that summarize the "generic rules" that govern most of the work published so far about micro-data learning.
1) Leveraging prior knowledge is key for micro-data learning: It should not be feared. However, the prior knowledge should be as explicit and as generic as possible. 2) Use as much data as possible from each trial (e.g., trajectory data, not only reward value): When data are scarce, every bit matters. 3) Take the time to choose what to test next (active learning): Computers are likely to become faster in the future, but physics will not accelerate; it is therefore a sensible strategy to trade data resources for computational resources. It is still desirable, but less critical on the long term, to design algorithms that are fast enough to run on embedded systems. 4) Every estimate (or model) should come with a measure of its uncertainty: When very little data are available, models will never have enough data to be "right" for the whole search space; algorithms must take this fact into account and reason with this uncertainty. 5) If needed, use expensive algorithms before the mission: Since we mostly care about online adaptation, we can have access to time and resources before the mission (access to computing clusters, GPUs, etc.) Finally, we would like to give a few recommendations for practical usage of micro-data algorithms.
1) Low-DOF Robots: For robots with less than 10 DOFs, model-based PS algorithms should be the choice of the researcher. Algorithms like Black-DROPS [99] and PILCO [100] will operate within reasonable computation time and will learn in very few trials. 2) High-DOF Robots: For robots with higher dimensional state/action space but with low dimensional policy spaces, BO approaches will provide the best tradeoff between computation time and learning convergence. If a prior model or simulator is available, algorithms like IT&E [15] and MF-ES [89] should be on the front line of learning in just a few trials. 3) Complex Robots: For robots with higher dimensional state/action space and high dimensional policy spaces, model-based PS with priors on the dynamics will provide the most data-efficient results at the expense of increased computation cost. Algorithms like Black-DROPS with GP-MI [17] and VGMI [132] effectively exploit parameterized simulators and should be able to learn in a handful of trials even for complex robots. 4) Raw Observations: When the observation (or state) space is very high dimensional (e.g., visual input), SimTo-Real methods combined with online adaptation (e.g., SimOpt [144]) should provide the best results. In all cases, a good policy space and initialization of the policy parameters (e.g., from demonstrations [62]) will accelerate learning.