LQR-trees with Sampling Based Exploration of the State Space

TL;DR

This paper enhances the LQR-tree algorithm by integrating a sampling-based exploration method, enabling more reliable synthesis of feedback control laws for complex systems from diverse initial conditions.

Contribution

It introduces a randomized motion-planning approach to improve demonstration generation in the LQR-tree algorithm, expanding its applicability.

Findings

More reliable feedback control synthesis for complex systems.

Effective exploration of uncharted state space regions.

Enhanced performance over previous LQR-tree implementations.

Abstract

This paper introduces an extension of the LQR-tree algorithm, which is a feedback-motion-planning algorithm for stabilizing a system of ordinary differential equations from a bounded set of initial conditions to a goal. The constructed policies are represented by a tree of exemplary system trajectories, so called demonstrations, and linear-quadratic regulator (LQR) feedback controllers. Consequently, the crucial component of any LQR-tree algorithm is a demonstrator that provides suitable demonstrations. In previous work, such a demonstrator was given by a local trajectory optimizer. However, these require appropriate initial guesses of solutions to provide valid results, which was pointed out, but largely unresolved in previous implementations. In this paper, we augment the LQR-tree algorithm with a randomized motion-planning procedure to discover new valid demonstration candidates to initialize the demonstrator in parts of state space not yet covered by the LQR-tree. In comparison to the previous versions of the LQR-tree algorithm, the resulting exploring LQR-tree algorithm reliably synthesizes feedback control laws for a far more general set of problems.

Tables

Table 1. Table 1 : Number of added demonstrations N dem subscript 𝑁 dem N_{\mathrm{dem}} , success rate of the NLP demonstrator s dem subscript 𝑠 dem s_{\mathrm{dem}} and total CPU time in minutes t total subscript 𝑡 total t_{\mathrm{total}} . A star denotes that some runs exceed 10 hours CPU time mark (TO). All values are averages using 5 runs.

	exploring LQR-tree			simple LQR-tree			funnel LQR-tree
Ex.	$N_{\mathrm{dem}}$	$s_{\mathrm{dem}}$	$t_{\mathrm{total}}$	$N_{\mathrm{dem}}$	$s_{\mathrm{dem}}$	$t_{\mathrm{total}}$	$N_{\mathrm{dem}}$	$s_{\mathrm{dem}}$	$t_{\mathrm{total}}$
Pnd	36	100%	1.1	39	4%	10.6	18	1%	17.2
Pndc	557	100%	27.4	∗1365	∗50%	TO	∗224	∗34%	∗548.1
Quad_initial_set1	139	100%	62.9	∗0	∗0%	TO	∗0	∗0%	TO
Quad_initial_set2	276	100%	114.5	12	10%	46.4	14	3%	196.7

Equations

$$\dot{x}=F(x,u)$$

$${\varphi }_{\mathrm{LQR}}(x,\mathcal{T})=\underset{(\tilde{x},\tilde{u})\in \mathcal{T}}{\mathrm{argmin}}{V}_{(\tilde{x},\tilde{u})}(x)$$

$$\ddot{\theta }=\frac{1}{m{l}^2}\left(u+mgl\sin \theta -b\dot{\theta }\right),$$

$$\underset{(\tilde{x},\tilde{u})\in \mathcal{T}}{\mathrm{argmin}}\underset{x\in {\mathcal{R}}_{\mathrm{counter}}}{\mathrm{ming}}{V}_{(\tilde{x},\tilde{u})}(x)$$

$${\eta }^H(x,x_{\mathrm{rand}})=\frac{\eta (x,x_{\mathrm{rand}})-{\eta }_{\min }}{{\eta }_{\max }-{\eta }_{\min }}+\frac{n-n_{\min }}{n_{\max }-n_{\min }},$$

$$\varphi (x,\mathcal{T})=\underset{(\tilde{x},\tilde{u})\in \mathcal{T}}{\mathrm{argmin}}\left\{V_{(\tilde{x},\tilde{u})}(x)\text{s.t.}{V}_{(\tilde{x},\tilde{u})}(x)\le d_{(\tilde{x},\tilde{u})}\right\},$$

Full text

1 Introduction

This paper provides an algorithm that automatically synthesizes a feedback control policy for systems of ordinary differential equations that stabilizes the system into the goal. The algorithm is based on the construction of LQR-trees [19, 17] that consist of a tree of trajectories, so called demonstrations [16], stabilized using linear quadratic regulator (LQR) feedback control laws. These stabilized demonstrations are used to cover the investigated set: Either a conservative region of attraction of the goal set can be computed for each demonstration [19], or these regions can be estimated via system simulations [17].

The key component in both versions of this algorithm is a demonstrator, a procedure that provides control inputs that steer the system into the goal set. In previous work [19, 17, 4], this demonstrator took the form of a trajectory optimization method [2]. However, such solvers require appropriate initial guesses to provide valid results. If these guesses are not good enough, the demonstrator regularly fails, causing the LQR-tree to progress slowly, if at all. This was the case in the implementation of LQR-trees in [17], where the demonstrator was initialized with failed system simulations generated during the LQR-tree algorithm. This turned out not to be sufficient [17] and our computational experiments support this observation.

In this paper, we remedy this issue by extending the LQR-tree algorithm with exploration of the state space based on randomized motion-planning. More specifically, we use rapidly-exploring random trees (RRT) [11] to further extend the LQR-tree into areas of the state space that are not yet stabilized by the current LQR-tree. The newly discovered connections then serve as initial solutions to the original demonstrator based on a trajectory optimization method. This demonstrator subsequently provides finalized optimized demonstrations that are added to the LQR-tree.

We provide computational experiments on several examples of dimension up to twelve that illustrate the practical applicability of the method and we compare our generation of demonstrations to the one in [17]. In this comparison, the exploring LQR-tree algorithm is more reliable and often significantly faster.

The structure of the paper is as follows. In Section 2, we state the precise problem and discuss related work. In Section 3, we briefly describe the LQR-tree algorithm. In Section 4, we present the main contribution of this paper, the integration of randomized motion-planning (RRT) into the generation of demonstrations for the LQR-tree algorithm. In Section 5, we describe the details of our implementation and provide computational experiments. And finally, Section 6 contains a conclusion.

2 Problem Statement and Related Work

Assume a control system

[TABLE]

where $F\colon\mathbb{R}^{n}\times\mathbb{R}^{m}\mapsto\mathbb{R}^{n}$ is a smooth function. Let $U\subset\mathbb{R}^{m}$ be a bounded set of control inputs. For a given initial point $x_{0}$, a time horizon $T>0$ and a continuous control input $u\colon[0,T]\mapsto U$, we denote the corresponding solution of (1) by $\Sigma(x_{0},u)$. We use the same notation for the solution with a feedback control law $u\colon\mathbb{R}^{n}\times[0,T]\mapsto U$.

Let $I\subset\mathbb{R}^{n}$ be a compact set of initial states, $O\subset\mathbb{R}^{n}$ be a set of obstacles and $G\subset\mathbb{R}^{n}$ be a compact set of goal states. Our goal is to construct a feedback control law $u\colon\mathbb{R}^{n}\times[0,T]\mapsto U$ such that $\Sigma(x_{0},u)$ reaches $G$ for all $x_{0}\in I\setminus G$ while staying outside of $O$.

We base our construction on LQR-trees [17, 19, 4]. These use a library of demonstrations consisting of system trajectories with desired control inputs from various states in $I$ and generalize these demonstrations to all states in $I$ using a tracking based on linear-quadratic regulator (LQR) [14].

The construction of an LQR-tree requires a demonstrator [16] that generates suitable demonstrations that reach the goal set $G$ under all given constraints. This demonstrator is usually based on trajectory optimization [2] that reduces the problem to nonlinear programming (NLP). However, such solvers require appropriate initial guesses, for example, taken from previous system simulations generated during the LQR-tree construction [17]. However, such heuristics often fail [17], an observation that the computational experiments in this paper confirm. This causes the construction of the LQR-tree to slow down, making it difficult for the LQR-tree to cover the whole set $I$. Hence, as stated in [17], “… a motion planner … robust to poor initialization is therefore desirable.”

Hence we propose to exploit sampling based path planning algorithms [12], namely rapidly-exploring random trees (RRT) [11], to further explore the state space and find new demonstrations during the LQR-tree construction. Rapidly-exploring random trees are known to efficiently find solutions to path-planning problems both in theory [9] and in practice [3].

3 LQR-trees

In this section, we describe the LQR-tree algorithm [19, 17, 4] in more details, introducing the necessary background and more detailed motivation for our contribution, which we will introduce in the next section. We reduce our attention to the simulation-based variants [17, 4], but our contribution applies to [19] as well. The LQR-tree algorithm constructs an LQR-tree, which consists of a set of demonstrations and a set of LQR tracking controllers to follow these demonstrations. Thus, the LQR-tree provides a feedback control law for any state in $I$ that chooses a suitable demonstration and applies the corresponding feedback tracking controller. Provided that the LQR-tree is well designed, the resulting feedback has the desired property, reaching $G$ from $I$ without visiting $O$.

Let us first specify the form of demonstrations that an LQR-tree consists of. They are open loop trajectories as defined in [19, 4], extended here to also include obstacles.

Definition 1**.**

Let $X\subset\mathbb{R}^{n}$ and $U\subset\mathbb{R}^{m}$ be bounded sets, let $O\subset\mathbb{R}^{n}$ be a set of obstacles, and let $T>0$. A demonstration from $x_{0}\in X\setminus G$ is a system trajectory $(x,u)$ with $x\colon[0,T]\mapsto X$ and $u\colon[0,T]\mapsto U$, both continuous, that satisfies the control system (1), and for which $x(0)=x_{0}$, $x(T)\in G$, and $x(t)\notin O$ for all $t\in[0,T]$.

Assume a set of demonstrations $\mathcal{T}$. For each demonstration $(\tilde{x},\tilde{u})\in\mathcal{T}$, we consider a tracking controller based on LQR [14]. We denote the LQR tracking controller by $u_{\mathrm{LQR}}^{(\tilde{x},\tilde{u})}$. This LQR controller is characterized by cost matrices $Q,Q_{0}\in\mathbb{R}^{n\times n}$ and $R\in\mathbb{R}^{m\times m}$ that we will assume to be positive definite and the same for all demonstrations. We denote the corresponding value function assigning to each state its cost-to-go by $V_{(\tilde{x},\tilde{u})}$.

Let $x_{0}\in I$ be a state from which we wish to reach the goal states using the demonstrations in $\mathcal{T}$. In the presence of multiple demonstrations, we need to choose a specific one to follow which we refer to as the target demonstration. To that end we use a definition [4] that generalizes more concrete rules used earlier [19, 17].

Definition 2**.**

An assignment rule $\phi$ is a function that for any set of demonstrations $\mathcal{T}$ and point $x\in\mathbb{R}^{n}$ selects an element from $\mathcal{T}$.

The LQR value functions $V_{(\tilde{x},\tilde{u})}$ provide a suitable basis for such an assignment rule [19]. We define

[TABLE]

The triplet of the set of demonstrations, the corresponding set of LQR tracking controllers and the assignment rule $\phi$ defines a feedback control law for all states in $I$. More specifically, the feedback control law to steer the system from $x_{0}\in I$ is given for all $x\in\mathbb{R}^{n}$ and all $t\in[0,T]$ by $u(x,t)=u_{\mathrm{LQR}}^{\phi(x_{0})}(x,t)$. We further refer to the triplet as an LQR-tree.

Assume an initial set of demonstrations $\mathcal{T}$ which is used to construct an LQR-tree. In general, such an LQR-tree does not provide a feedback control law that steers all states in $I$ to the goal set $G$ while avoiding obstacles $O$. To determine which demonstrations must be further added to $\mathcal{T}$, we consider an algorithm based on sampling of the initial set $I$ [17, 4].

Assume a sample $x_{0}$. The algorithms tests via a simulation of the system, whether the feedback control law given by a set of demonstrations $\mathcal{T}$ reaches the goal set $G$ from $x_{0}$ while staying outside of $O$, which we refer further as the LQR-tree being successful for $x_{0}$. If the LQR-tree is not successful for $x_{0}$, the algorithm uses the demonstrator to generate a new demonstration from $x_{0}$, see Algorithm 1.

Assume that all demonstrations have a certain leeway, a clearance [9], for tracking controllers to meet all the constraints while tracking target demonstrations [19]. More precisely, assume that for some fixed $\delta>0$, all demonstrations $(\tilde{x},\tilde{u})$ meet $B_{\tilde{x}(t)}^{\delta}\notin O,B_{\tilde{u}(t)}^{\delta}\in U$ for all $t\in[0,T]$, and $B_{\tilde{x}(T)}^{\delta}\in G$, where $B^{\delta}_{x}$ denotes an open ball with a centre in $x$ and a diameter $\delta$. Then under some mild assumptions on the assignment rule $\phi$ [4], Algorithm 1 produces a feedback control law that reaches the goal set $G$ while avoiding obstacles $O$ after finitely many iterations [4], that is, after adding finitely many demonstrations to $\mathcal{T}$.

A key part of successful implementation of Algorithm 1 is a demonstrator that provides new demonstrations for the LQR-tree. The implementation [17] uses a demonstrator based on trajectory optimization [2] that is initialized from the failed simulations obtained in step 3a. However, as observed in [17] for a pendulum on cart example, only about 30% of all attempts of the demonstrator succeeded which indicates that many initializations were poor.

To demonstrate this fact further, assume the following inverted pendulum example

[TABLE]

where $m=0.5$, $l=1$, $b=0.1$ and $g=9.81$. In this example, we wish to steer the system to $[0,0]$ from the initial set $I=[-4,4]\times[-5,5]$ with the control inputs bounded by $[-1.25,1.25]$, which we restrict further for demonstrations to $[-1,1]$. We set the LQR costs as $Q=Q_{0}=I$ and $R=I$ and start the LQR-tree algorithm with a demonstration $\tilde{x}=0$ and $\tilde{u}=0$. We base the demonstrator on a direct optimal control solver [2] with the same quadratic cost. The NLP problem is constructed via the Hermite-Simpson collocation method [6]. We set the length of demonstrations as $T=10$ with a time step of $h=0.05$. We initialize the NLP solver via failed simulations. The failure rate of the demonstrator is very high (97%) and hence, the LQR-tree algorithm struggles to make progress, as can be seen in Fig. 1.

4 Exploring LQR-trees

To solve the issue of generating new demonstrations in step 3b of the LQR-tree algorithm, which is crucial for its efficiency and convergence, we will exploit rapidly-exploring random trees (RRT) [11]. The RRT algorithm explores the state-space and generates valid initial estimates of the demonstrations which we pass on to the NLP demonstrator whose result then forms new demonstrations.

The RRT algorithm is an incremental algorithm that creates a tree in the state space by connecting new states to already explored ones. Its main strength is that the RRT algorithm does not require a steering function [12], a function that connect two states with a dynamically feasible trajectory, which generally requires a solution to a boundary value problem. Instead, the RRT algorithm extends the tree by propagating the system via chosen control inputs [9, 13].

Let us assume that Algorithm 1, after some iterations, has arrived at the set of demonstrations $\mathcal{T}$ corresponding to the blue trajectories in Fig. 2, all terminating in the goal (G). Assume that we now need to generate a new demonstration from a counterexample (C) whose target demonstration is indicated by the end of the black dotted line. For this, we need to properly initialize the NLP based demonstrator. Also, we want to avoid calling the demonstrator too often, since it is costly.

We now use the RRT algorithm to explore the state space by building two trees: a counterexample tree (red) that is built from the counterexample and a demonstration tree (magenta) that is built from a discrete sampling of one of demonstrations in $\mathcal{T}$—initially the given target demonstration.

During the growth of both trees, for each newly visited state, we test whether a system simulation using the current LQR-tree results in a new demonstration from this state. In the case of the counterexample tree, we search for states for which the current LQR-tree is successful (green). Analogously, in the case the demonstration tree, we search for states from which the current LQR-tree feedback control law fails (cyan). In the first case, we obtain a valid system trajectory from a counterexample to the goal. The second case expands the LQR-tree into new areas where the original feedback control law failed and thus, it further enlarges the parts of the state space where the first case can occur. In both cases, the recovered system trajectories serve as an initial solution for the NLP based demonstrator, which provides the final demonstrations that are added to the LQR-tree. We further denote calls to the demonstrator by a function $demo$. Note that demonstrations must have a clearance to assure that the LQR-tree is successful for all states that are close enough to the demonstrations, and thus the simulation must be tested with this clearance in mind.

The resulting algorithm that explores the state space and generates new demonstrations in step 3b of the LQR-tree algorithm is Algorithm 2.

Concerning the concrete variant of the RRT algorithm to use here, there are numerous possibilities that extend the original RRT algorithm with the aim of improving its performance [8, 15]. We need a variant that works well for general kinodynamic problems. We also want to exploit the presence of another RRT-like tree, the current LQR-tree, to grow it backwards, trying to connect it to the original RRT tree.

For this, we adapt bidirectional RRT-connect [10] which is a popular [18] greedy variant of RRT. In this algorithm, the first tree, which we refer to as primary is extended in a random direction $x_{\mathrm{rand}}$ (generated uniformly from $X$) using the so called best control inputs [12]. We use a discretely sampled set of actions, searching for the best action via systematic enumeration.

If the node fails to extend closer to $x_{\mathrm{rand}}$, the whole process is repeated. If the node extends successfully, the algorithm continues to extend the tree until it fails. Afterwards, the secondary tree is extended in the direction of the last extension of the primary tree. Finally, the primary tree and secondary are swapped and the process repeats. See Algorithm 3 for the full description.

5 Computational Experiments

We implemented the exploring LQR-tree algorithm in MATLAB 2020b on a PC with Intel Core i7-10700K with 32GB of RAM. We constructed our NLP demonstrator using the toolbox CasADi [1] with the internal optimization solver Ipopt [20], performing discretization via the Hermite-Simpson collocation method [6].

The implementation uses a slightly modified assignment rule $\phi_{\mathrm{LQR}}$ that reduces its computation time by first narrowing the search of the target demonstration to the $N=500$ closest demonstrations according to the Euclidean distance.

In Algorithm 3 we terminate the loop in step 2 whenever either a new demonstration is discovered (both in the counterexample tree and the demonstration tree), or a maximum number of extensions of any given tree is exceeded.

In RRT algorithms, the choice of a good metric $\eta$ for selecting which state to expand is heavily problem dependent [12]. In our computational experiments, we used the weighted Euclidean metric augmented with the history-based selection [7]. In this modification, the number of failed extensions of any given state is tracked. A new history based metric $\eta^{H}$ is defined as

[TABLE]

where $n$ is a number of failed extensions of $x$, $n_{\mathrm{max}}$ is a maximum number of failed extensions, $n_{\mathrm{min}}$ is a minimum number of failed extensions, $\eta_{\mathrm{max}}$ is the maximum distance between $x_{\mathrm{rand}}$ and nodes of the tree, and $\eta_{\mathrm{min}}$ is the minimum distance between $x_{\mathrm{rand}}$ and nodes of the tree.

Our implementation also modifies Algorithm 2 to not only terminate when a new demonstration is successfully generated from $x_{\mathrm{counter}}$, but also when the counter-example tree reaches a certain maximal number of nodes. If this happens, Algorithm 2 is restarted from the next detected counterexample. This avoids excessive growth of the RRT-trees and a resulting slow-down due to costly nearest neighbour computations.

All demonstrations require a given clearance. However, this may make the generation of a new demonstrations difficult for the LQR-tree feedback control law, since it is based on the tracking of some previous demonstration which could meet the clearance condition only tightly. Hence, we added a certain tolerance (5% in our implementation) for obstacles and state bounds that is sufficient for the Algorithm 2 to pass the solution to $demo$. Naturally, the NLP demonstrator must produce the new demonstration with the clearance as prescribed, which always happened in our experiments.

We consider an universal time step $h$, which we use both in computations of demonstrations for time discretization and in the RRT algorithm as a simulation step. Finally, in all numerical experiments, we terminated the LQR-tree algorithm after reaching 1000 samples without a new counterexample.

5.1 Examples

In our numerical experiments, we considered the following problems.

Inverted pendulum

We return to the inverted pendulum example (3). We restrict the demonstrations by state bounds $X^{\prime}_{\mathrm{B}}=\pm\left[8,12\right]$. We set the time step $h$ as $0.05$ and the length of demonstrations to $T=10$. In the RRT algorithm, we used the standard Euclidean distance without history based sampling and we reduced the control inputs to the two values $-1$ and $1$. We set the maximum number of extensions of a single tree within a single bidirectional expansion, that is, before a new evaluation of the closest demonstration, to $500$ and the maximum size of a counterexample tree to $5000$.

Inverted pendulum on a cart

We use a slightly modified existing example [17]. Here, we order the variables as $\left[x,\theta,\dot{x},\dot{\theta}\right]$. We use the initial set $I=\left[-0.2,0.2\right]\times\left[-\pi,\pi\right]\times\left[-1.5,1.5\right]\times\left[-8,8\right]$, state bounds $X_{\mathrm{B}}\pm\left[0.45,4\pi,15,50\right]$, control bounds $U=[-60,60]$, and goal set $G=\{x\in\mathbb{R}^{4}\mid x^{T}\mathrm{diag}(10,1,1,1)x<0.05\}$. We set the length of demonstrations to $T=7.5$ and restrict them to state bounds $X^{\prime}_{\mathrm{B}}=\pm\left[0.36,2\pi,8,25\right]$ and the control inputs to $U^{\prime}=[-36,36]$.

The cost matrices of the LQR tracking $Q=\mathrm{diag}(100,30,100,10)$ and $R=0.1$, and use the same cost for generation of demonstrations in the NLP demonstrator. We set the time step $h$ to $0.025$. In Algorithm 3, we used the standard Euclidean distance with the history-based selection [7] and we reduced the input selection to the two values $-36$ and $36$. We set the maximum number of extensions of a single tree within a single bidirectional RRT expansion to $500$ and maximum size of a counterexample tree to $5000$.

Quadrotor

We use the simplified model from [5, (2.61)–(2.66)], where we set $m=1$ and $g=9.8$ and we order the state variables as $\left[x,y,z,\phi,\psi,\theta,\dot{x},\dot{y},\dot{z},\dot{\phi},\dot{\psi},\dot{\theta}\right]$. We bound the state variables $x$ and $y$ by $-\left[8,12\right]\times\left[12,12\right]$ and set bounds for the rest to $\pm\left[5,1,4\pi,1,10,\ldots,10\right]$. We bound the control inputs by $U=[-2.5,2.5]^{4}$. We also consider three cylindric obstacles with bases $\left\{y\in\mathbb{R}^{2}\mid(y-a)^{T}A(y-a)\leq\alpha\right\}$, where we set $a=[2,-3.5],[2,3.5],[2,0]$, $\alpha=8,8,7$ and $A=\mathrm{diag}(1,45),\mathrm{diag}(1,45),\mathrm{diag}(25,1).$

We consider two variants of this problem with different initial sets. The first variant uses a rectangle $[4,7]\times[-2,2]$, and the second one enlarges the initial set to subset of $[-4,8]\times[-7,7]$, see Fig. 3. In both variants all the other variables are set to zero. We use the goal set $G=\{x\in\mathbb{R}^{12}\mid\left\lVert x\right\rVert<0.05\}$. We set length of demonstrations to $T=10$ and restrict them to $-\left[5,9\right]\times\left[9,9\right]$ in $x$ and $y$. The bounds for the rest are $\pm\left[0.5,2\pi,0.5,5,5,5,2,2,2\right]$. The other values are restricted to $U^{\prime}=[-2,2]^{4}$ and $\alpha^{\prime}=16,16,16.8$.

The cost matrices of LQR tracking are $Q=I$ and $R=I$. The same cost was used for generation of demonstrations in the NLP demonstrator. We set the time step $h$ to $0.1$. In the RRT algorithm 3, we used the weighted Euclidean distance with $W=\mathrm{diag}(5,5,1,\ldots,1)$ with the history-based selection [7] and we reduced each input selection to the two values $-2$ and $2$ considering all its combinations. We set the maximum number of extensions of a single tree within a single bidirectional RRT expansion to $500$ and maximum size of a counterexample tree to $5000$.

5.2 Results

We compare the exploring LQR-tree algorithm with two reference algorithms. In the first reference algorithm, which we call the simple LQR-tree algorithm, we use a simple heuristic, initializing the demonstrator with the system simulation that detected the given counterexample $x$. We also implemented an LQR-tree algorithm as described in [17] which we will further call the funnel LQR-tree algorithm. This algorithm uses a slightly different assignment rule to ours

[TABLE]

where the values $d_{(\tilde{x},\tilde{u})}$ represent estimations of so called funnels [17] and are computed as follows: when the algorithm detects a counterexample, it lowers the value of the corresponding $d_{(\tilde{x},\tilde{u})}$ such that the counterexample is no longer assigned to the demonstration. Then the algorithm tries to assign a new demonstration via (5). Provided that no simulation is successful, it chooses one failed simulation based on the cost used in the NLP demonstrator. If some state is not assigned to any demonstration, the algorithm proceeds the same way as the simple LQR-tree algorithm.

For all three algorithms, all results are averages over 5 runs. As can be seen from these results, initiating demonstrations from failed system simulations (the simple LQR-tree and the funnel LQR-tree algorithms) can lead to poor performance of the NLP demonstrator, as was already observed in [17]. This can result in an excessively large runtime of the overall algorithm and even failure of the construction of the LQR-tree itself, when the heuristic is unable to make progress. In comparison, the demonstrator in the exploring LQR tree algorithm did not fail even once and all problems were solved. In the Example 3, the simple LQR tree algorithm actually performed better overall, but for the cost of enlarging the initial set to ensure that the heuristic could make progress.

The main disadvantage of the exploring LQR-tree algorithm is that it may generate a significantly larger LQR-trees. The reason for this is that the exploring LQR-tree algorithm can add new demonstrations even outside of the initial set. This allows the growth of the LQR-tree to be more gradual, but computing these additional demonstration can be costly (in Example 3, it was over 50% of the overall runtime). Hence, it may be beneficial to add further restrictions on adding demonstrations outside of the initial set. The resulting LQR-trees can also be pruned from these additional demonstrations once the initial set is covered.

6 Conclusion

In this paper, we presented the exploring LQR-tree algorithm that incorporates a bidirectional RRT algorithm for generation of initial estimates of demonstrations. These estimate are subsequently handled by the demonstrator. In comparison to the previous work, which included a simple heuristics that used failed simulations, this approach is more reliable, often faster and allows solution to problems that could not be handled by the previous algorithms.