Probabilistically Safe Policy Transfer

TL;DR

This paper introduces a probabilistic framework for safe policy transfer in robotics, ensuring damage constraints are maintained during learning while optimizing performance.

Contribution

It proposes a novel method that predicts safety impacts of policy updates, enabling safe learning with damage constraints at every step.

Findings

The approach effectively balances performance improvement and safety constraints.

Experiments demonstrate the method maintains safety while enhancing robot performance.

The method predicts safety outcomes of policy modifications in real-time.

Abstract

Although learning-based methods have great potential for robotics, one concern is that a robot that updates its parameters might cause large amounts of damage before it learns the optimal policy. We formalize the idea of safe learning in a probabilistic sense by defining an optimization problem: we desire to maximize the expected return while keeping the expected damage below a given safety limit. We study this optimization for the case of a robot manipulator with safety-based torque limits. We would like to ensure that the damage constraint is maintained at every step of the optimization and not just at convergence. To achieve this aim, we introduce a novel method which predicts how modifying the torque limit, as well as how updating the policy parameters, might affect the robot's safety. We show through a number of experiments that our approach allows the robot to improve its performance while ensuring that the expected damage constraint is not violated during the learning process.

Figures

Equations

$$\underset{\pi }{\mathrm{maximize}}$$

$$E[d|\pi ]\le D_{\mathrm{safe}}$$

$$u(s)\le u_{\lim }$$

$$r_t^{\prime }=r_t-\lambda \max (0,u(s_t)-u_{\lim }^{\prime }{)}^2$$

$$E[d|\pi ]$$

$$=\int p(U)p(d(\pi )|U)d(\pi )\text{d}d$$

$$\le \int p(U)p(d(\pi )|U)d_{\max }(\pi )\text{d}d$$

$$=p(U)d_{\max }(\pi )\int p(d(\pi )|U)\text{d}d$$

$$=p(U)d_{\max }(\pi )$$

$$p_u(\pi )d_{\max }(\pi )\le D_{\mathrm{safe}}.$$

$$T^{\prime }=\max (\min (T,T_{\lim }),-T_{\lim }).$$

$$d_{\max }(\pi ,T_{\lim })=\alpha T_{\lim }$$

$$p_u(\pi ,T_{\lim })T_{\lim }\le D_{\mathrm{safe}}$$

$$p_u^{\prime }$$

$$\le p_u+\Delta p_{u1}+\Delta p_{u2}.$$

$$T_{\lim }=D_{\mathrm{safe}}/p_u^{\prime }.$$

$$\displaystyle p(T^{\prime}|s)=\begin{cases}\frac{1}{\sigma\sqrt{2\pi}}\exp\Big{(}\frac{-(T^{\prime}-\mu)^{2}}{2\sigma^{2}}\Big{)},&\text{if }-T_{\rm lim}<T^{\prime}<T_{\rm lim}\\ F_{\mu,\sigma}(-T_{\rm lim}),&\text{if }T^{\prime}=-T_{\rm lim}\\ 1-F_{\mu,\sigma}(T_{\rm lim}),&\text{if }T^{\prime}=T_{\rm lim}\\ 0&\text{otherwise}\end{cases}$$

$$T_D=(T\le -T_{\lim })\cup (T\ge T_{\lim }).$$

$$p(T\in T_D|s)=1-F_{\mu ,\sigma }(T_{\lim })+F_{\mu ,\sigma }(-T_{\lim }).$$

$$p(T\in T_D)={\int }_{s}p(s)p(T\in T_D|s)ds.$$

$$p(T\in T_D)$$

$$=E_{s\sim p(s)}[1-F_{\mu ,\sigma }(T_{\lim })+F_{\mu ,\sigma }(-T_{\lim })].$$

$$\Delta p_{u1}=p(T\in T_D).$$

$$\Delta p_{u2}=(1-A_I).$$

$$\underset{\theta }{\mathrm{maximize}}$$

$$E[D_{KL}({\pi }_{{\theta }_{old}}(\cdot |s)||{\pi }_{\theta }(\cdot |s))]\le {\delta }_{KL}$$

$$KL(p_1||p_2)=\log \frac{{\sigma }_2}{{\sigma }_1}+\frac{{\sigma }_1^2+({\mu }_1-{\mu }_2{)}^2}{2{\sigma }_2^2}-\frac{1}{2}$$

$$|{\mu }_1-{\mu }_2|=\sigma \sqrt{2{\delta }_{KL}}.$$

$$A_I({\mu }_1,\sigma )$$

$$=2F_{{\mu }_1,\sigma }({\mu }_1-\sigma \sqrt{{\delta }_{KL}/2})$$

$$A_I=2E_{s\sim p(s)}[F_{{\mu }_1,\sigma }({\mu }_1-\sigma \sqrt{{\delta }_{KL}/2})].$$

$$p_u^{\prime }=p_u+\Delta p_{u1}+\Delta p_{u2}$$

Full text

I Introduction

Reinforcement learning has shown to be a powerful technique leading to impressive performance across a number of domains [31]. For example, reinforcement learning methods have been used to train a computer to outperform human performance in 49 Atari games [14, 18]. Recently, a learning-based method was used to train a computer (AlphaGo) to beat a champion Go player [27]. Similar methods have also been used to train robots to perform a number of difficult tasks in simulation [10, 26] and in the real world [8, 22].

However, when applied to robotics tasks in the real world, learning-based methods that adapt their parameters online have the potential to be dangerous. For example, a self-driving car or quadrotor that performs online learning might suddenly adapt its parameters in such a way that causes it to crash into a pedestrian or another obstacle.

Although there are many ways in which a robot can be dangerous, for this work, we focus on the dangers caused by a robot manipulator applying high torques. Such a robot might break the object that it is interacting with, break a nearby object, or damage itself.

One approach that is often used in practice is to place the robot in an isolated environment while training, where it cannot break anything of importance. In such an environment, the robot can perform learning with minimal risk. However, if the isolated training environment is different from the test environment, then this difference can lead to unexpected and possibly dangerous behavior. For example, suppose we want a robot to operate around or collaboratively with people; the isolated training environment would likely not contain any people, and thus the training environment would not be representative of the test environment in which the robot must operate.

Another solution is to train the robot in simulation. Efforts can be made to make the simulation mimic the test environment as much as possible; however, despite one’s best efforts, there will likely be differences between simulation and reality, leading to policies that do not work correctly when brought into the real world. If the robot must re-learn how to behave in the real world, there is a risk of the robot operating dangerously while it is adapting its behavior.

We propose that, when a robot is placed in a new environment, it should initially operate at low torques. Only once the robot has demonstrated sufficient safety in its new environment do we allow it to operate at higher torques. Our approach thus makes the assumption that, if the robot violates a safety constraint (which we will define), less damage will be caused if the robot is operating at lower torques.

However, imposing safety-based torque limits during training brings up new questions that have not been sufficiently explored in the robot learning literature: How do we define the safety of the robot? How do we decide whether to increase the torque limits? How do we ensure that the robot always performs at a safe level of operation even while learning to improve its performance?

We propose an approach to dealing with these challenges for the case of a robot manipulator (shown in Figure 1). We evaluate our approach quantitatively, and videos of our results are also available online111https://youtu.be/fprZHyP_50o. We note that our method is not a complete solution to the robot safety problem, and there are still many safety-related challenges that our approach does not address. Still, we believe our work provides a contribution towards confronting these issues surrounding learning and safe robot operation.

II Related Work

Policy Transfer. A number of recent papers have explored how to transfer policies from one domain to another [5, 6, 7, 11, 20, 24, 28, 29]. The goal of these papers is typically to minimize the number of samples required in each new environment by transferring knowledge from simulation or from previous environments. However, these approaches do not investigate the potential safety issues that can occur when a policy is first run in a new environment, before any adaptation has occurred.

AI Safety. Safety has recently become a popular topic within the AI community, as indicated by several recent survey papers on the topic [2, 12, 21]. Amodei, Olah, et al. organize problems of AI safety into five major categories [2]. One of their categories is safe exploration: “how to ensure that exploratory actions in RL agents don’t lead to negative or irrecoverable consequences that outweigh the long-term value of exploration.” A related problem is “robustness to distributional shift$\,\ldots\,$how to avoid having ML systems make bad decisions$\,\ldots\,$when given inputs that are potentially very different than what was seen during training.” Both of these issues are relevant to the problem discussed in this paper.

Safe exploration. A review of past work on safe exploration is given in [2, 12, 21]. Our method falls into the category of “constrained criterion$\,\ldots\,$in which we want to maximize the expectation of the return while keeping other types of expected utilities lower than some given bounds” [1, 12]. Typical constraints involve ensuring that either the expectation of the return exceeds a threshold [9, 13, 23], the variance of the return remains below a threshold [4], or that any state is reachable from any other state (ergodicity) [15, 19]. However, these approaches only guarantee that the constraints will hold at the optimal solution; in contrast to our approach, they do not analyze whether the constraints will hold at every step of the optimization.

A recent trajectory optimization algorithm (T-CHOMP) can add a cost that keeps the velocity low near obstacles [3]. However, this method does not learn to adapt its parameters based on errors in the model. In contrast, our approach performs online learning while maintaining damage constraints.

III Overview

In order to obtain safe learning, we pose an optimization problem: we want to train a robot to achieve a task as optimally as possible while maintaining an expected safety constraint. In order to maintain the expected safety constraint, we impose safety-based torque limits on the robot. In Section IV, we will define our optimization problem more precisely, and in Section V, we will describe our method for maintaining the expected safety constraint while optimizing the policy.

IV Problem Setup

IV-A Minimizing Expected Damage

Suppose that a robot behaves according to some policy $\pi(a\>|\>s)$ which maps from states $s$ to actions $a$ (we will abbreviate the policy as $\pi$). At each timestep $t$, the robot visits a state $s_{t}$ and takes action $a_{t}$, leading to a new state $s_{t+1}$ and accrueing a reward, $r_{t}=r(s_{t},a_{t},s_{t+1})$. Reinforcement learning problems normally aim to maximize the expected return, defined as the discounted sum of rewards, $R=\sum_{t}\gamma^{t}r_{t}$, for some constant $\gamma$.

However, operating the robot also has a risk of causing damage to nearby objects or damaging the robot itself. On any timestep, the agent might cause some amount of damage $d$ to occur. Our goal is to maximize the expected return while keeping the expected damage below a given threshold:

[TABLE]

where $\operatorname{\mathbb{E}}$ denotes an expectation that incorporates the stochasticity from the environment, the policy, or any other sources of variation. The variable $D_{\rm safe}$ is a constant that specifies how much expected damage we are willing to tolerate. For example, in the autonomous vehicle domain, we might specify that we want the expected number of major accidents per 100 million miles traveled to be less than 0.1. Note that the damage $d$ is assumed to be a non-negative quantity (i.e. $\forall\pi,d\geq 0$), so we can set $D_{\rm safe}$ arbitrarily close to 0 to minimize the amount of expected damage that the robot might cause. We refer to equation 2 as the damage constraint.

The problem that we wish to deal with is that, when we first operate the robot using our initial policy, the robot might violate the damage constraint. Further, as we optimize the policy, the policy may change in ways that also violate the constraint. Our goal is then to limit the amount of expected damage caused by the robot while the policy is being adapted.

IV-B Task Safety

In order to minimize expected damage, the robot must have some notion of what might cause damage. We define a safety constraint:

[TABLE]

where $u(s)$ is some function over states. For example, we can specify that an autonomous vehicle must remain some minimum distance from any pedestrian. We assume that the robot might cause damage only when the constraint is violated (i.e. when $u(s)>u_{\rm lim}$). To discourage the robot from violating this constraint, we use a penalty method for optimization, with the reward received at time-step $t$ as

[TABLE]

where $u^{\prime}_{\rm lim}\leq u_{\rm lim}$. By increasing $u^{\prime}_{\rm lim}$ over time until $u^{\prime}_{\rm lim}=u_{\rm lim}$ and by increasing $\lambda$ over time, we can ensure that our final policy, at convergence, will maximize the expected return without violating the safety constraint.

However, the problem is that penalty methods only guarantee that the safety constraint (equation 3) will not be violated at convergence. On the other hand, for robotics, any unsafe action can be dangerous or harmful, including actions taken before convergence. We thus design a method that ensures that, even if the robot violates the safety constraint at intermediate steps of the optimization, the robot will not cause a significant amount of damage.

We now define the expected damage in terms of safety violations. We assume that, due to differences between simulation and reality and due to uncertainty in the environment, avoiding violating the safety constraint entirely is impossible. Let $U$ be the event of violating the safety constraint from equation 3 (and possibly causing damage) when acting under policy $\pi$, and let $p_{u}(\pi)=p(U)$. We refer to $p_{u}(\pi)$ as the “unsafety rate,” which we abbreviate as $p_{u}$. Note that no damage can occur unless the event $U$ has occurred.

Further, let $d_{\rm max}(\pi)$ be the maximum amount of damage that can be caused by policy $\pi$ if it violates the safety constraint (as explained below, different policies can cause different amounts of damage during constraint violations). Then we can upper-bound the expected damage by

[TABLE]

where equation 6 comes from the total probability theorem combined with the fact that $p(d(\pi)\>|\>\neg U)=0$ because we assume that damage can only occur when the constraint is violated. Thus our damage constraint (equation 2) becomes

[TABLE]

Our goal is to impose constraints on the policy such that, even if the policy violates the safety constraint (i.e. even if $p_{u}(\pi)>0$), the amount of expected damage will never exceed the threshold $D_{\rm safe}$.

IV-C Torque Limits

To concretize our problem, we assume that the actions chosen by the robot are torques that will be applied to its various motors. In order to limit the damage $d_{\rm max}(\pi)$ that can be caused by the robot, we introduce torque limits into our robot operation. At each time step, we limit the torque (in absolute value) that the robot can output to some threshold $T_{\rm lim}$. Specifically, if our policy $\pi$ outputs a torque $T$, then we instead apply a torque

[TABLE]

We use the same torque limit for all joints.

By applying torque limits, we limit the amount of damage that can be caused by the robot acting under any policy. For example, if an autonomous vehicle is driving slowly, then even if it moves unsafely (due to, for example, a slippery road or poor visibility conditions), its slow speed will result in less damage if the vehicle gets into an accident. Similarly, if a robot manipulator bumps into a fragile object, it will have a lower chance of breaking the object if it is moving at lower torques, and if it bumps into a person, then the person will be less likely to become injured.

The damage that can be caused by the robot is now a function of both the policy $\pi$ and the torque limit $T_{\rm lim}$, which we write as $d_{\rm max}(\pi,T_{\rm lim})$. Analyzing the damage that can be caused at different torque levels is outside of the scope of this paper, so we assume that the maximum amount of damage that can be caused in an unsafe state is linear in the torque limit, i.e.

[TABLE]

for some constant $\alpha>0$. Our method does not depend on the specific form of this function, and other forms can be easily used. We can fold $\alpha$ into the safety limit $D^{\prime}_{\rm safe}=D_{\rm safe}/\alpha$, so without loss of generality, we assume that $\alpha=1$.

Our damage constraint now becomes

[TABLE]

where the probability of violating the safety constraint $p_{u}$ is now a function of both the policy $\pi$ as well as the torque limit $T_{\rm lim}$, since both affect the robot’s operation. This equation is fairly intuitive: if the robot is operating at a low torque limit which is unlikely to cause much damage, we accept a greater probability of violating the safety constraint; if the robot is operating at a larger (and more dangerous) torque limit, then we insist on a lower probability of violating the safety constraint. Our approach is not restricted to torque limits but can be used with any type of limit that controls the amount of damage that can be caused by an unsafe policy, such as velocity constraints.

Our initial policy might be unsafe, so we initially force the robot to operate at a low torque limit. Although a robot operating at a lower torque limit can cause less damage, limiting the torques that the robot can apply also might limit the rewards that can be obtained by the robot. A robot that can only apply low torques will take a longer time to achieve each task, and thus it will typically accrue lower rewards (for many typical reward functions). We define the Probabilistically Safe Policy Transfer problem as that of deciding how to modify the policy and adjust the torque limit $T_{\rm lim}$ in order to maximize the expected return while maintaining the expected damage constraint.

One potential side-effect of this framework is that, in some cases, varying the torque limits can increase the convergence time of the policy: for each new value of the torque limit, the policy might need to adapt its behavior, leading to slower convergence. However, we accept this cost in convergence time due to the benefit of safer robot behavior.

V Method

V-A Overall Algorithm

Now that we have defined what it means for a robot to operate safely (in a probabilistic sense), we describe a method for safely optimizing a policy. The overall algorithm for Probabilistically Safe Policy Transfer is shown in Algorithm 1. We begin with an initial policy $\pi$ and an initial torque limit of $T_{\rm lim}=T_{\rm min}$ where $T_{\rm min}<D_{\rm safe}$, which ensures that, even if $p_{u}=1$, our expected damage $p_{u}\,T_{\rm lim}$ will not exceed the damage limit. Using our initial policy and torque limit, we perform a set of rollouts. Based on these rollouts, we update the policy, as is normally done in reinforcement learning.

Next, we adjust our torque limit. We would like to increase our torque limit as much as possible, but we need to ensure that the damage constraint will continue to hold for the next iteration with the updated policy. We achieve this as follows: we first emperically compute the current unsafety rate $p_{u}$ from the rollouts. We then anticipate how much the unsafety rate might increase in the next iteration, given by $\Delta p_{u}$. Let $\Delta p_{u1}$ be the amount that the unsafety rate might increase as a result of changing the torque limit (described in Section V-B), and let $\Delta p_{u2}$ be the amount that the unsafety rate might increase as a result of changing our policy (described in Section V-C). The probability of the union of these cases is bounded by the sum of the individual probabilities. Using this bound gives us the worst-case estimate of:

[TABLE]

Then, we adjust (increase or decrease) the torque limit $T_{\rm lim}$ such that, if the unsafety rate increases to $p^{\prime}_{u}$, the damage constraint would hold with equality, i.e. we set

[TABLE]

We then perform new rollouts using our updated policy and new torque limit, and we repeat until convergence.

V-B Changing the Torque Limit

We assume that our policy maps states to a Gaussian distribution with mean $\mu(s)$ and variance $\sigma^{2}(s)$, and to choose an action, we sample from this distribution. This is a common representation in deep reinforcement learning for continuous control problems [16, 17, 25].

To ensure that the damage constraint is not violated, we impose safety-based torque limits on our robot. The torque $T$ is sampled from the distribution $\mathcal{N}(\mu,\sigma^{2})$ and then truncated down to a torque $T^{\prime}$ based on the torque limit (see Equation 11). The distribution for the applied torque (i.e. after truncation) can thus be represented by a truncated Gaussian:

[TABLE]

where $F_{\mu,\sigma}(T)$ is the cumulative distribution function of the Gaussian with mean $\mu$ and variance $\sigma^{2}$ (we have omitted the dependency of the the mean and variance on the state $s$). Because truncation is applied after sampling, $T_{\rm lim}$ contains the probability mass of all torques $T\geq T_{\rm lim}$; similarly, $-T_{\rm lim}$ contains the probability mass for all torques $T\leq-T_{\rm lim}$. This distribution is shown in Figure 2 (top).

The probability density resulting from an increase in the torque limit from $T_{\rm lim}$ to $T^{\prime}_{\rm lim}$ is illustrated in Figure 2 (bottom). The probability density remains the same for all torques for which $-T_{\rm lim}<T<T_{\rm lim}$, and the probability density changes for torques in the range

[TABLE]

The probability that a torque would previously have been sampled from this range is given by

[TABLE]

This distribution is conditioned on the state $s$. In order to compute the unconditional probability over torques, we must integrate over the different states:

[TABLE]

The distribution over states $p(s)$ that are visited depends on the actions that are taken; thus, $p(s)$ depends on the policy $\pi$ as well as the torque limit $T_{\rm lim}$. However, estimating the effect of the torque limit on $p(s)$ is complex, so we approximate $p(s)$ using the distribution from the previous iteration (a similar approximation is often made for policy gradient methods; see, e.g., [25]). In practice, we replace this integral with the Monte-Carlo estimate, i.e.

[TABLE]

This quantity is the probability that a different torque will be sampled due to changing the torque limit. If all such cases lead to an unsafe action by our policy, then by increasing the torque limit, the unsafety rate might increase by

[TABLE]

This quantity is used by our algorithm in Equations 15 and 16 to determine the new torque limit.

Note that our estimate of $\Delta p_{u1}$ does not depend on the amount by which the torque limit was increased. Our approach is fairly conservative: we assume that if any torque $T$ is sampled that is greater than our previous torque limit, then this new torque might lead to an unsafe action, regardless of how close that torque is to the previous torque limit. Although such an approach might in some cases be conservative, our method errs on the side of ensuring safe robot operation.

The above analysis holds only for torque limit increases and not decreases. Nonetheless, in the case of torque limit decreases, we still use the above formula to predict changes to the unsafety rate. Based on the above analysis, such an approach is conservative, because decreasing the torque limit (i.e. making the torque limit tighter) will cause no new torques to be sampled that could not have been sampled on the previous iteration. Thus, using the same formula in both cases results in a method that is both simpler and more conservative than handling each case separately.

V-C Updating the policy

In order to find the optimal policy in the test environment, we must update the policy parameters. However, updating the policy parameters can increase the unsafety rate, possibly leading to a violation of the damage constraint. To examine the effect of changing the policy parameters on the unsafety rate, we compute the amount that the policy distribution can change. An example is shown in Figure 3. The degree to which the policy remains the same is given by the area of intersection, $A_{I}$, between the new policy and the old policy (shown in green). The amount that the policy distribution has changed is then given by $1-A_{I}$, which is equal to the area of the blue section in Figure 3. This probability mass has shifted to the red area of this figure, which must also have an area of $1-A_{I}$ in order for the new policy distribution to integrate to 1. As in the previous section, if we conservatively assume that changes in the policy distribution all lead to unsafe states, then the unsafety rate might increase by

[TABLE]

This quantity is used by our algorithm in Equations 15 and 16 to determine the new torque limit.

If the policy is represented by a complex function such as a neural network, it is typically difficult to predict how updating the parameters will affect the policy distribution. However, if we are using Trust Region Policy Optimization (TRPO) [25] to update the policy parameters, then we will have a good estimate on how the distribution can change between iterations. In TRPO, we update the policy according to the following optimization:

[TABLE]

where $\theta_{old}$ are the old policy parameters, $\theta$ are the new policy parameters, $D_{KL}$ is the KL-divergence, $\delta_{KL}$ is a constant, and $A_{\theta_{old}}(s,a)$ is the advantage function, computed as the empirical return minus a baseline [10]. The constant $\delta_{KL}$ limits the amount by which the KL-divergence of the policy can change on each iteration. Thus, although we do not know exactly how the policy has changed from one iteration to the next, when using TRPO we know that the KL-divergence of the policy cannot change more than $\delta_{KL}$.

We would like to use this information to estimate $(1-A_{I})$. The KL-divergence between two Gaussian distributions is given by

[TABLE]

where $p_{1}=\mathcal{N}(\mu_{1},\sigma^{2}_{1})$ and $p_{2}=\mathcal{N}(\mu_{2},\sigma^{2}_{2})$. If we make the simplifying assumption that the variance stays roughly the same between each iteration (i.e. $\sigma_{1}=\sigma_{2}=\sigma$), and we set the KL divergence equal to the constraint $\delta_{KL}$, then we get

[TABLE]

As illustrated in Figure 4, the area of intersection between the two Gaussians of equal variance would then be given by

[TABLE]

where $F_{\mu_{1},\sigma}(\cdot)$ is the cumulative distribution function for a normal distribution of mean $\mu_{1}$ and variance $\sigma^{2}$. The mean and variance are conditioned on the state, so as before, we can use an expectation to remove the dependency on the state:

[TABLE]

We can then use this estimate in Equation 24 to predict how much the unsafety rate might increase as a result of updating our policy.

VI Results

VI-A Experimental Setup

We test our method both with a simulated PR2 (Section VI-B) and with a real PR2 (Section VI-C); pictures of each robot can be seen in Figure 1. To illustrate our method, we use as an example task that of swirling a cup in a circle while keeping the cup oriented vertically (so that the contents do not spill). Examples of safe and unsafe behavior for this task can be seen in Figure 5, and videos of our results are available online222https://youtu.be/fprZHyP_50o.

Our safety limit is defined with respect to the orientation of the end-effector; in our experiments, the end-effector must point straight down and maintain a fixed vertical orientation. If $\theta$ is the angle of the end-effector with respect to the downward direction, then our safety constraint is defined as $\theta\leq\theta_{\rm lim}$, where $\theta_{\rm lim}$ is defined as the maximum angle that the robot can hold the cup without a risk of spilling. The unsafety rate $p_{u}$ then measures the fraction of timesteps for which the $\theta>\theta_{\rm lim}$. We assume that the amount that is spilled (i.e. the damage) will be greater if the constraint is violated at high torques (i.e. if the robot tips the cup and applies a large torque, moving quickly). Additionally, our experiments demonstrate that, at higher torques, the robot will have a harder time recovering from small errors, leading to larger errors and more damage.

The reward is designed to encourage the robot to swirl the cup in a horizontal circle. The modified reward used by our reinforcement learning algorithm is defined using the penalty method approach of equation 4. In our experiments, we set $u^{\prime}_{\rm lim}=0$ and $\lambda=0.001$. Our state space is defined by the left arm’s joint-angles, the joint velocities, and the vector $z$ which measures the downward orientation of the end-effector; for optimal safety, we should have $z=(0,0,-1)$. The actions of our policy are the 7 joint torques for the left arm of the PR2.

We pre-train the policy in simulation using the Mujoco [30] simulator. Our policy is represented as a neural network with 3 hidden layers of 64 nodes each, with tanh non-linearities after each hidden layer. The policy is optimized using TRPO [25] and Generalized Advantage Estimation [26] with a linear baseline, as implemented by rllab [10]. Each episode consists of 200 timesteps, where each timestep is 50 milliseconds, and we pre-train the policy with 50 episodes per batch. We use a discount factor of $\gamma$ = 0.95, $\lambda=0.98$ from Generalized Advantage Estimation, and a KL-divergence constraint of $\delta_{KL}=0.01$. During pre-training, we re-initialize the robot arm to a random initial configuration before each episode, so that the policy will be robust to the initial position of the robot.

After pre-training, we test our policy on a robot that may have different model parameters from those that were used during pre-training. For example, if we are pre-training in simulation and then transferring our policy to the real world, the real robot may have different values for friction, damping, or other model parameters.

Our policy is fine-tuned in the test environment in order to learn a safe policy that will correctly implement the desired behavior. Because we desire for our policy to quickly converge during fine-tuning, we increase our KL-divergence constraint to $\delta_{KL}=0.05$ and we use only 5 episodes per batch. Other parameters are kept the same as during pre-training, except as specified below. In order to ensure that the state-visitation distribution stays relatively fixed from one time-step to the next, we ensure that the torque limit $T_{\rm lim}$ does not increase by more than 5% between each iteration (for our method as well as for the baselines). This is similar to the KL-divergence constraint that is placed on the policy, which prevents the policy from changing too dramatically in each iteration.

At test time, we will be varying the torque limit $T_{\rm lim}$ to enforce the expected damage limit, using our method described in Section V. In order to make the training environment match to the test environment as much as possible, we also vary the torque limit during training. We additionally input the torque limit into the network as an additional input; thus, our policy can learn a range of behaviors for varying torque limits. Although this is not necessary for our method to work (our method will still keep the expected damage below the limit even without this modification), our experiments show that this change is helpful for fast convergence of the policy during test time.

VI-B Simulation Results

Our simulated test environment allows us to test the robustness of our algorithm under controlled environmental variations; we will show results on a real PR2 in Section VI-C. We test our algorithm for Probabilistically Safe Policy Transfer in a simulated test environment that differs from our training environment in that all masses and damping parameters are reduced by a factor of 10-100 and moments of inertia are reduced by a factor of 10.

We initialize the torque limit $T_{\rm lim}$ to 0.1 N$\cdot$m and increase it as specified by our method up to a maximum value of 3 N$\cdot$m. We use $D_{\rm safe}=0.5$, except where indicated otherwise. For each method that we evaluate below, we run the method with 5 random seeds, in order to test the robustness of each approach.

Adaptive vs Fixed Torque Limit. First, we show the benefit of using our adaptive torque limit method compared to a baseline of using a fixed torque limit. Shown in Figure 6, our method starts with a low torque limit (0.1 N$\cdot$m) and adjusts the torque limit over time. In contrast, the baseline uses a fixed torque limit of 3 N$\cdot$m. Note that our method does not always increase the torque limit; sometimes it may decrease it based on the unsafety rate.

Figure 7 shows the expected damage from each of these approaches. During the initial iterations of the policy, both methods perform relatively poorly, leading to a large number of constraint violations and hence a high unsafety rate ($p_{u}$). The fixed torque limit approach operates at large torques even during these initial stages, leading to a large expected damage ($p_{u}\,T_{\rm lim}$), as shown. In contrast, our adaptive torque limit approach initially operates at a low torque limit (0.1 N$\cdot$m), and thus the initial expected damage is kept low. Our method adapts the torque limit appropriately to keep the expected damage below $D_{\rm safe}$ as the policy adapts.

Ablation Analysis. Next, we perform an ablation analysis to demonstrate the importance of each component of our method. In our full method, we predict that the probability of unsafety $p_{u}$ might increase from its current value due to two factors:

• •

Changing the torque limit might cause $p_{u}$ to increase by $\Delta p_{u1}$ (Section V-B)

• •

Updating the policy might cause $p_{u}$ to increase by $\Delta p_{u2}$ (Section V-C)

Thus, our full method predicts that, as a result of both of these factors, the probability of unsafety $p_{u}$ might increase to

[TABLE]

We then set the torque limit to a value of $T_{\rm lim}=D_{\rm safe}/p^{\prime}_{u}$, ensuring that the expected damage constraint will continue to be satisfied.

In this section, we explore the effect of removing different components of our method; specifically, we explore the following variants for the predicted probability of unsafety:

1. v2)

Not predicting effect of the torque limit increase:

$p^{\prime}_{u}=p_{u}+\Delta p_{u2}$ 2. v3)

Not predicting effect of the policy update:

$p^{\prime}_{u}=p_{u}+\Delta p_{u1}$ 3. v4)

Not predicting either effect:

$p^{\prime}_{u}=p_{u}$

In each case, we set the torque limit to a value of $T_{\rm lim}=D_{\rm safe}/p^{\prime}_{u}$ as before. We run each method with 5 random seeds.

The result of our ablation analysis is shown in Figure 8. As can be seen in this figure, removing any part of our method results in a violation of the expected damage limit $D_{\rm safe}$. Thus, in order to observe the expected damage limit, it is important to predict both how changing the torque limit and how updating the policy parameters will affect the probability of unsafety.

Varying the expected damage limit. In Figure 9, we show the effect on our policy of varying $D_{\rm safe}$, the expected damage limit. We test our method with four different values of $D_{\rm safe}$. In each case, our method adjusts the torque limit accordingly to try to keep the expected damage below $D_{\rm safe}$. In some trials we observed the emperical expected damage exceed the safety threshold due to the stochasticity of our policy in small batch sizes; with larger batch sizes, our method observed the safety limit in all of our experiments.

VI-C Real-world Results

To test whether our method works in the real world, we also fine-tune our pre-trained policy using the real PR2. Our real robot appeared to have much greater friction than that of our simulation; to overcome the static friction, we initialized the torque limit $T_{\rm lim}$ to 1.8 N$\cdot$m, and we increased all torques output by the policy by 30%. We set $D_{\rm safe}=1.3$. To avoid unsafe actions due to the stochasticity of the policy, we reduced the policy variance by a factor of two for real-world testing. We run our method three times, with different random seeds. As shown in Figure 10, our method succeeds in keeping the expected damage below the damage limit.

We also tested whether our method can be used to successfully train a robot to swirl a full cup without spilling. In order to verify this, we filled a cup with almonds and tested both our method as well as the baseline (with no torque limits). For each method, we counted the number of almonds that were spilled after 10,000 timesteps of our policy (8.3 minutes). Based on 5 repeated experiments, our method drops an average of 7.8 almonds, compared to 18.2 almonds for the baseline (this result is statistically significant with $p<0.05$). Videos of our results are available online333https://youtu.be/fprZHyP_50o

VII Conclusion

We present a probabilistic framework for defining robot safety in terms of maximizing the expected return while keeping the expected damage below a given limit. As the policy adapts to its new environment, our method adjust the torque limit accordingly to ensure that the robot remains safe. Importantly, our method predicts how changes to the policy or changes to the torque limit might affect the unsafety rate, in order to keep the expected damage below the limit at every iteration.

VIII Acknowledgments

This work was partially supported by an NSF CAREER award (#1351028) and by Berkeley Deep Drive.