Robot Motion Planning in Learned Latent Spaces

07/26/2018 ∙ by Brian Ichter, et al. ∙ Stanford University 0

This paper presents Latent Sampling-based Motion Planning (L-SBMP), a methodology towards computing motion plans for complex robotic systems by learning a plannable latent representation. Recent works in control of robotic systems have effectively leveraged local, low-dimensional embeddings of high-dimensional dynamics. In this paper we combine these recent advances with techniques from sampling-based motion planning (SBMP) in order to design a motion planning framework for high-dimensional robotic systems (e.g., humanoids, or even systems where planning occurs in the visual space). Specifically, the learned latent space is constructed through an autoencoding network, a dynamics network, and a collision checking network, which mirror the three main algorithmic primitives of SBMP, namely state sampling, local steering, and collision checking. Notably, these networks can be trained through only raw data of the system's states and actions along with a supervising collision checker. Building upon these networks, an RRT-based algorithm is used to plan motions directly in the latent space -- we refer to this exploration algorithm as Learned Latent RRT (L2RRT). This algorithm globally explores the latent space and is capable of generalizing to new environments. The overall methodology is demonstrated on two planning problems that are well beyond the reach of standard SBMP, namely a visual planning problem, whereby planning happens in the visual (pixel) space, and a humanoid robot planning problem.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 12

page 13

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Motion planning is a fundamental problem in robotics whereby one seeks to compute a dynamically-feasible trajectory connecting an initial state to a goal region while avoiding obstacles. This problem quickly increases in difficulty with the dimensionality of the system and the complexity of the dynamics [1]. For some high-dimensional systems, and even differentially-constrained systems, sampling-based motion planning (SBMP) techniques have emerged as a particularly successful approach. SBMP avoids the explicit construction of the state space and instead maintains an implicit representation of it through three algorithmic primitives: sampling the state space, steering (or connecting) to nearby sampled states, and collision checking such connections [1, 2]. This implicit representation is global and increasingly accurate as samples are added [1]. However, applying SBMP to robotic systems with, say, more than ten dimensions, quickly becomes intractable. This precludes its application (at least directly) to cases where, for example, plans are computed from visual inputs [3, 4] or the dynamics are very high-dimensional and complex, as for humanoids [5].

A promising solution to address this challenge is represented by recent works on learning-based control, which leverage learned, low-dimensional manifolds embedded within the state space to which the dynamics of a robotic system are mainly restricted to [3, 6, 7, 8]. For example, a bipedal humanoid walking robot is generally in gait and upright, and a visual representation of a robot has a “true" underlying lower-dimensional dynamical representation. These works, however, primarily focus only in local regions, and can not be directly applied to compute motion plans whereby one needs to globally explore the state space. Our key insight to scale these techniques to robot motion planning is to leverage the local effectiveness of low-dimensional latent representations to learn a latent space in which one can directly use SBMP. In other words, the idea is to build a global implicit representation of the latent space through only local connections. The latent space is constructed through an autoencoding network, a dynamics network, and a collision checking network, which mirror the three aforementioned algorithmic primitives of SBMP, namely state sampling, local steering, and collision checking. Specifically, the space is learned through an autoencoding network with learned latent dynamics, which provides the ability to sample the latent space and connect local states through dynamically-feasible trajectories. Notably, this network only requires raw data of the system’s states and control inputs to be trained. Separately, a collision checking network is trained to predict whether a trajectory between two latent states is collision free given a specific problem environment. Collectively, these networks provide a methodology to globally search the latent space (in our case, through an RRT-based algorithm), in a way that generalizes well to new environments and is general enough to apply to a broad class of problems, including visual planning and complex dynamics problems. The final trajectory can then be projected to the full state space through the autoencoding network and used in conjunction with the aforementioned local control methods to effectively control the robotic system along the planned trajectory. We refer to this methodology as Latent Sampling-based Motion Planning (L-SBMP).

Related Work:

The field of representation learning seeks to learn representations of data to extract useful information for classifiers or other predictors

[9, 10, 11]

. This often takes the form of manifold learning, i.e., learning lower-dimensional manifolds embedded within high-dimensional data. Representation learning has been applied along the entire robotic stack – from perception

[12], to decision making and planning [13, 14], to control and dynamics [3, 6, 7, 15]. Recently, these methods have seen particular success in the field of control. Embed to Control [3] and Robust Locally-Linear Controllable Embeddings [6] present approaches to learning to control robotic systems directly from raw images. Both methods learn a locally-linear embedding via a variational autoencoder and directly perform stochastic optimal control on the latent space. [4] learns to predict the results of actions in visual spaces and uses model-predictive control to plan local manipulator actions. In contrast, our work learns a non-linear latent space (allowing generalization to more complex systems) and a collision checking network (allowing generalization to new environments).

In the context of robot motion planning, Universal Planning Networks (UPN) [8] learn a plannable latent representation in which gradient descent can be used to compute a plan that minimizes an imitation loss (learned from an expert planner). Our methodology, L-SBMP, learns a similar latent space to UPN (by enforcing dynamics in the latent space), but performs a global search of the latent space to find motion plans. In addition, L-SBMP does not rely on an expert planner, which for many problems may not be available. [16] uses a Gaussian process latent variable model to learn a low-dimensional representation and then uses inference to solve the planning problem via a particle-based approach. Compared to L-SBMP, the latent variable model must be well initialized and using inference does not allow a global search of the latent space. Motion Planning Networks (MPNet) [17]

learns a low-dimensional representation of the obstacle space and uses a feedforward neural network to predict the next step an optimal planner would take given an initial state, goal state, and the obstacle representation (trained via an asymptotically optimal planner). MPNet approaches the problem of accelerating solutions to planning problems for which solutions to similar problems can be provided by demonstration, whereas our work attempts to solve previously intractable planning problems. Lastly, within sampling-based planning, learning has been used to replace parts of the algorithmic stack, such as the collision checker

[18] or the sample distribution [19]. L-SBMP too learns a collision checking network, though directly in the latent space, and, in a manner, learns where to sample by choosing samples for the exploration algorithm directly from encoded training states.

It is important to note that, in practice, the L-SBMP methodology can be, and should be, combined with many of the aforementioned approaches. In many cases, L-SBMP may be an initialization for the latent spaces in [3, 6, 8]. Furthermore, these approaches can be used to improve the trajectory generated by L-SBMP and to control the motion along it.

Statement of Contributions: The contribution of this paper is threefold. First, we present the Latent Sampling-based Motion Planning (L-SBMP) methodology, which comprises an autoencoding network, a dynamics network, and a collision checking network to enable planning through the latent space. These networks can be trained through only raw data of the system’s states and control inputs along with a supervising collision checker. Second, building upon L-SBMP, we present an RRT-based algorithm, termed Learned Latent Rapidly-exploring Random Trees (L2RRT), to plan motions directly in the latent space. L2RRT efficiently and globally explores the learned manifold by maintaining an implicit representation of the space formed through sampling encoded states and dynamically propagating nearby trajectories in the tree (under the supervision of the collision checking network). The final latent trajectory is then projected back to the full state space through the autoencoding network. Third, we demonstrate our approach on two planning problems that are well beyond the reach of standard SBMP, namely a visual planning problem, whereby planning happens in the visual (pixel) space, and a humanoid robot planning problem.

Organization: The remainder of the paper is organized as follows. Section II introduces the problem we are approaching and provides necessary background. Section III outlines the L-SBMP methodology for learning the plannable latent space. Section IV presents L2RRT, the sampling-based exploration strategy used to globally search the latent space. Section V demonstrates the performance of L-SBMP on a visual planning problem and a humanoid planning problem. Section VI summarizes our findings and suggests several avenues for future work.

Ii Problem Statement

In this section we formulate the motion planning problem we wish to solve. We then briefly overview sampling-based motion planning algorithms in order to give necessary background and to motivate our methodology. Lastly, we present the problem of learning plannable latent spaces.

Ii-a Robot Motion Planning Problem

Let and denote the state space and control input space, respectively, of a robotic system. Let the dynamics of the robot be defined by

(1)

where and denote the state and control input of the system at time and denotes the continuous-time system dynamics. To make the dynamics learning problem tractable we consider a discrete-time formulation. Note however that we still consider the continuous-time underlying dynamics to determine collisions. Let the discrete-time dynamics of the robot be defined by

(2)

where and denote the state and control input of the system at time step and denotes the discrete-time system dynamics.

Let define the free state space of the robot and let define the obstacle space, such that . Let us be given an initial state and a goal region . A trajectory for the robot is defined as a series of states and control inputs , where is the number of time steps in the trajectory. Further, let denote the continuous curve traced by the robot’s trajectory (connecting ). We make this distinction here to clarify that collision checking should be done along the continuous trajectory connecting discrete states. A trajectory is said to be collision-free if . A trajectory is said to be feasible if it connects the initial state and goal region, i.e., and , is collision-free, and is dynamically feasible, i.e., for . In this work, we are interested in the following problem,

Problem 1 (Motion Planning Problem).

Given a motion planning problem , find a feasible trajectory . If no such trajectory exists, report failure.

Ii-B Sampling-based Motion Planning

Sampling-based motion planning has emerged as a highly effective algorithmic paradigm for solving complex motion planning problems. SBMP avoids the explicit construction of the state space and instead maintains an implicit, searchable representation. This representation is formed by a set of probing samples which are locally connected and verified via a “black box” collision checking module [1]. This methodology enables a global search and guarantees on probabilistic completeness and often asymptotic optimality [20, 21].

One particularly successful family of sampling-based motion planning algorithms is the rapidly-exploring random tree (RRT) [2]. As our exploration algorithm is built from this, we now overview RRT to clarify each algorithmic primitive. The algorithm begins by initializing a tree with the initial state , and subsequently iteratively builds a tree through the state space. At each iteration, a state in the free state space is sampled, . The nearest node within the tree to is selected as the expansion node, . The node is then expanded towards , forming a new sample . If the trajectory connecting and does not intersect , i.e., is collision-free, then is added as a node to the tree. This continues until either time elapses or a pre-determined number of samples is reached. The approach is capable of globally searching the state space only through three algorithmic primitives: (1) sampling, (2) locally connecting, and (3) collision checking. The key idea in this work is that, by ensuring each of these algorithmic primitives can be applied in a learned, low-dimensional latent space representing the robotic system, we can directly use SBMP to compute plans for the full state space.

Ii-C Plannable Latent Spaces

The robotic systems we consider in this work may have complex-dynamics and high-dimensional state spaces. For example, these may be pixel representations of the robot and environment or they may be highly-dynamic, high-dimensional robots. In these cases standard approaches to solving motion planning problems are computationally intractable. Even approaches like SBMPs, which were initially created for high-dimensional systems, have difficulty scaling well beyond ten dimensions even in the absence of dynamic constraints.

Our goal is to find the underlying manifold of the problem by learning a low-dimensional latent space model in which SBMP can be performed. Due to the complexity of the system, this space should be learned only through sequences of states and control inputs of the robot in operation and a separate local collision checker. Let denote the learned latent space and a latent state at time step . We seek to learn a mapping from to and a mapping from to for which latent dynamics are enforced over . We further learn a “black-box” collision checking function in the latent space. We thus wish to learn the following:

(3)

Iii Learning a Latent Space for Robotic Motion Planning

In order to plan on a low-dimensional latent space model, one needs the properties that: (1) the latent space can be sampled, (2) the dynamics are known, so as to connect nearby latent states, and (3) a local, latent trajectory can be classified as collision-free. It is also desirable that the latent samples can be mapped to the full space once a solution is found, so that the robotic system can execute the motion plan. Finally, we do not assume we have access to the true system dynamics , i.e., only observations of states and actions over time and a collision check.

The Latent Sampling-based Motion Planning (L-SBMP) architecture consists of three networks: (1) an autoencoder, (2) a latent local dynamics model, and (3) a collision classifier. The autoencoder projects the high-dimensional full state () into a lower-dimensional latent state (), and also allows decoding to form inputs for a subsequent controller. The dynamics model enforces local dynamics on the encoded latent space and allows the dynamics to be propagated. Finally, the collision classifier identifies if the connection between two nearby latent states will be possible given the problem environment. The latent space is trained from a series of trajectories from the robotic system in operation; i.e., a sequence of states and actions . The collision checking network is trained from a data set of nearby states and a label denoting if the connecting trajectory is in collision.

Iii-a Learned Latent Space and Dynamics

The first network in our architecture follows a standard treatment for autoencoders. Given a robotic system with state and latent state , we define an encoding network and a decoding network , with parameters and , respectively. These networks project the full state into the lower-dimensional latent space and then reconstruct the full state. Depending on the robotic system, such networks may be convolutional or fully connected networks. For this work we use an reconstruction loss.

The second network in our architecture learns, and subsequently enforces, local dynamics in the latent space. Let denote the dynamics network and its parameters. This network predicts the next state in the latent space, . The accuracy of this prediction is enforced through two losses. First, the prediction is decoded , and compared to the full state with an reconstruction loss. Second, the prediction is compared in the latent space to the next encoded state . In order to have a dynamically-consistent loss, we linearize the dynamics around and and compute the weighted controllability Gramian (also known as the reachability Gramian) as

(4)

The loss is then computed as the minimum energy between the prediction and the true next latent state, that is . Essentially this enforces that the loss in prediction is representative of the dynamics of the system, e.g., for a car, missing the latent state prediction forward or backward is less important than missing left and right. Note however, that initially, before the dynamics network has been trained, the weighted controllability Gramian from Eq. 4 may be ill-conditioned. We thus begin with an norm and gradually shift to the norm. We also add a small positive term to the diagonal of to ensure invertibility.

Iii-B Learning a Collision Checker

The third network in our architecture learns to identify if the continuous trajectory between two latent states will be in collision; we denote this network as , parameterized by

. This is a supervised learning process entailing binary classification; meaning, we assume we have a collision checker in the full state space capable of reporting if the trajectory is in collision – arguably, a very mild assumption. We note here our use of

as an input to the network. In SBMP

is generally only implicitly defined through the collision checker. We use it here to denote any environmental information available to the state space collision checker. This representation can be quite general as the neural network architecture has the capacity to arbitrarily project this information as necessary. For example, this may be workspace coordinates of the obstacles, an occupancy grid, or an image of the problem. This network is learned separately, after the encoder and dynamics have been learned. It is possible to learn this network through unsupervised learning by identifying regions of the state space that are rarely or never connected dependent on the environment. We leave this for future work.

Fig. 1: The L-SBMP network architecture. The encoder network is shown in blue, the decoder network in orange, the dynamics network in green, and the collision checking network in gray. The inputs are shown in purple.

Iv Planning in the Latent Space

We now present the Learned Latent Rapidly-exploring Random Trees (L2RRT) algorithm used to globally search the latent space learned as described in Section III. L2RRT is a SBMP algorithm within the rapidly exploring random trees (RRT) family of algorithms [2]. Briefly, the algorithm builds a tree, , through the latent space by sampling latent samples from the learned manifold and propagating dynamics from nearby tree nodes (under the supervision of the collision checking network). As the learned dynamics may be quite complex, the algorithm must rely on a dynamics propagation strategy, rather than a steering function, to connect local latent states.

The L2RRT algorithm is similar to the RRT-BestNear algorithm presented in [22], with samples restricted to the latent space and dynamic propagation through latent dynamics. Specifically, the algorithm is outlined in Alg. 1 and visualized in Fig. 2. The algorithm takes as input the planning problem in the full state space: the obstacle representation, initial state, , and goal region, . Note again, we abuse notation here with . Though traditionally in SBMP, is only implicitly defined through the collision-checker, we use it here to refer to any environmental information used for the state space collision checker.

To begin, the initial state and goal region are encoded into the latent space as and , respectively (line 1). The tree is initialized with the initial latent state (line 2). The algorithm then begins expanding the tree outwards into the latent space. At each iteration a sample, , is selected from a sample set (line 4). This set is comprised of latent samples generated by encoding a randomly drawn set of the robot in operation. That is, given a sequence of states (where is large to well cover the operational state space of the robot), we randomly select a sample set and encode it as . By selecting samples only from this set, L2RRT ensures that the exploration remains nearby the learned manifold in the latent space. L2RRT then selects a node in the tree for propagation by using the BestFirstSelection strategy outlined in [22] (line 5). BestFirstSelection selects the tree node within a ball radius, , with the lowest-cost trajectory111This cost can be fairly general, e.g., control cost or the number of time steps.. If no tree nodes are within the ball radius, the nearest tree node is returned. The ball radius parameter represents a tradeoff between exploration and exploitation of good trajectories; its value is discussed in the subsequent paragraph and at length in [22]. With in hand, L2RRT then forward propagates dynamics through with a randomly chosen control action for time , where is randomly chosen between and , following the Monte Carlo propagation procedure outlined in [22] (line 6). This gives a trajectory in latent space , where (line 7). Each pair of waypoints is then collision checked by for

. The probability that a local connection is collision-free can be computed as

(line 8). Thus, the acceptable probability threshold can be tuned to the required level of safety. Finally, if the propagated trajectory is collision free, is added to the tree (line 9). The exploration ends after a set amount of time or number of samples. If no trajectories end in the goal region , the algorithm reports failure (line 13). If any trajectories reach the goal region, the best trajectory11footnotemark: 1 is then selected and projected back to the full state space through (line 15-16). This outputs nominal control inputs as well as the full state space trajectory (which may be used as input to a controller or a trajectory optimizer).

0  , , ,
0  (, , )
1  Encode problem input into latent space: ,
2  Add to the tree
3  while time remains do
4     Sample
5     
6     Sample and
7     Propagate dynamics from for time steps, to generate latent trajectory
8     if  then
9        Add to the tree
10     end if
11  end while
12  if  then
13     Report failure
14  else
15     Select lowest-cost trajectory with its end in
16     Project back to full state space through and return , where is time steps to
17  end if
1 Learned Latent RRT Outline
(a) Lines 4-5
(b) Lines 6-7
(c) Lines 8-9
Fig. 2: Learned Latent RRT exploring the latent space, as described in Alg. 1. (1(a)) Sample and select lowest-cost tree node within a ball. (1(b)) Sample time and controls . Propagate dynamics with . (1(c)) Verify the new edge is collision free with . Add the node to the tree.

Briefly we provide discussion on how to choose values for the algorithm’s parameters. The ball radius represents a tradeoff between exploiting good trajectories and exploring with new ones. This value should be tuned according to the system and from discussion in [22]. The maximum dynamic propagation time controls, roughly, the length of edge. For subsequent results this was approximately set so the robot with optimal control can traverse the full state space in . The value of reflects the required level of safety in the collision checking network. We found most collision classifications yielded probabilities less than 1% or greater than 99%, however, for subsequent results this threshold was set as . Finally, we also use a technique called goal-biasing, in which we sample more heavily from the goal region. For subsequent results we sample a state within the goal region 10% of the time.

Due to the approximate nature of the learned latent space, L2RRT does not enjoy formal completeness or optimality guarantees. An interesting avenue for future research is to investigate conditions under which theoretical guarantees for L2RRT can be derived.

V Experimental Results

In this section we demonstrate the effectiveness of our methodology on two planning problems from domains in which traditional motion planning approaches are intractable. The first is a visual planning problem entailing a point robot with single integrator dynamics navigating a cluttered environment based on visual inputs. The second is a humanoid planning problem where a humanoid robot has to maneuver amidst obstacles. The methodology was implemented in Python and Tensorflow

[23]. All data was collected on a Unix system with a 3.4 GHz CPU and an NVIDIA GeForce GTX 1080 Ti GPU. Example code can be found at github.com/StanfordASL/LSBMP.

V-a Visual Planning Problem

We consider a visual space planar problem similar to the one outlined in [3], though with a more complex obstacle space. This setup allows us to demonstrate the performance of the L-SBMP methodology to generalize to new environments by leveraging the algorithmic prior of separating collision checking from the dynamic propagation process. As we have access to the true underlying state, and the underlying planning problem is relatively simple, this problem allows us to compare our methodology against sampling-based motion planning algorithms with access to the true state of the system.

The full state of the visual problem is a pixel image rendered in MuJoCo showing both the robot and the obstacles in the scene. The robot is a point robot with single integrator dynamics. The obstacles are a random number of circles and squares with randomly generated locations and sizes. An example problem’s initial and goal states are shown in Figs. 2(a)-2(b). The training data for the autoencoder and dynamics network consists of 10,000 environments, each with a trajectory of 10 successive states and control inputs. The training data for the collision checking network consists of 25,000 environments, again with 10 pairs of states and a collision label.

The full state is projected down to a two dimensional latent space. The methodology applied to an image-based system requires some architectural changes to make the learning problem more tractable. The encoder network, , is a deep-spatial autoencoder [7]

, which encourages learning important visual features by using a convolutional neural network followed by a spatial soft arg-max. To create accurate reconstructions of the full state the decoder network is given as input an image of the environment in addition to the latent state. This additional input image may be the environment without the robot present or it could be an image with the robot from a different time step (e.g., the initial state for a planning problem).

(a) Initial state
(b) Goal state
(c) Latent space
(d)
Fig. 3: (2(a)-2(b)) The full state of the visual robot with obstacles (robot is shown in yellow) and initial and goal states for input to our methodology. (2(c)) The learned latent space colored by the position of the robot in the true underlying state space. States from the lower-left corner are green, lower-right are yellow, upper-right are red, and upper-left are blue. The encoded initial state is shown in blue and the goal state in red. States in collision are not visualized (empty white regions). (2(d)) The inverse of the weighted controllability Gramian in the state space (an ellipse representing equal energy costs). The learned latent space in the upper right is less dense so the ellipses are larger in the direction of the spread, thus penalizing errors less.

Fig. 2(c) shows the learned latent space for the problem in Fig. 2(a)-2(b). The methodology learns a latent space that captures the position of the robot and effectively removes latent regions within obstacles, though this obstacle set has never been seen before. Fig. 2(d)

shows the inverse weighted controllability Gramian in the latent space. Because the true system dynamics are consistent throughout the state space, this gives an opportunity to evaluate the weighted loss function. As desired, in regions of the state space that are more spread (i.e., the same control input allows more movement), errors are penalized less.

Fig. 4 shows two planning problems for this system, the planned trajectories in the full state space, and the L2RRT in latent space. L-SBMP is able to successfully generalize to these problems and find trajectories even through narrow passages. These global plans can then be fed into a local controller, such as [6], or a trajectory optimizer [8], to be executed.

(a) Initial and goal states
(b) Initial and goal states
(c) Decoded trajectory
(d) Decoded trajectory
(e) Latent space L2RRT
(f) Latent space L2RRT
Fig. 4: (3(a)-3(b)) Initial and goal states for the visual planning problem. (3(c)-3(d)) Planned trajectories decoded into the full state space. Note that collisions for this system are only determined by the center of the point robot. (3(e)-3(f)) L2RRT in the latent space, where the initial state and final trajectory are shown in green, the goal state in red, and collisions between states in black. States within the tree are color-coded by their cost (blue denotes low cost, red denotes high cost). Lastly, samples from the training data are used as samples in L2RRT and are shown in blue.

Fig. 5

shows the success rate and cost convergence curve (in terms of control input, i.e., distance) versus the number of samples. The success rate increases quickly at first before leveling below 100% (though all problems are solvable). The cost convergence curve follows a standard curve for SBMP, converging quickly at first before leveling out. The confusion matrix shows nearly 90% of collisions are correctly classified, with only 4% of true collisions classified as free. This false positive ratio could likely be reduced by including conservatism in the full state space collision checker. With 1000 samples, the algorithm takes on average 9 seconds.

(a) Success rate
(b) Cost
(c) Collision predictions
Fig. 5: Convergence curves and collision confusion table for visual planning problem.

We additionally compare these plans to plans computed in the true state space (given a perfect representation of the robot and obstacles in two dimensions) by the Fast Marching Tree (FMT) algorithm [21] and by RRT-BestNear [22] (which uses the same exploration strategy as L2RRT, but with knowledge of the true state space). We note that FMT relies on a two point boundary value problem solver to make local connections. Each algorithm is run with 2000 samples and 100 randomly generated planning problems. This allows FMT to explore the state space more efficiently than L2RRT or RRT-BestNear (which only use dynamics propagation). In terms of success rate of finding a solution, normalized to FMT, L2RRT is able to solve 92% of the problems while RRT-BestNear solves 96%. In terms of solution trajectory cost, L2RRT solves these problems with a 13% higher cost than FMT and RRT-BestNear solves with a 5% higher cost than FMT. From these results we make two observations. First, planning in the latent space incurs some loss (in terms of success rate and cost), however, this loss is relatively small considering the algorithm is only given a very high-dimensional, inexact, visual representation of the state. Second, if the latent space were forced into a more restrictive class of dynamical systems (e.g., locally-linear) with a two point boundary value problem solver available, the L-SBMP methodology could leverage algorithms like FMT to more efficiently explore the state space. We leave this to future work.

V-B Humanoid Robot

Our second numerical experiment shows the methodology with a high-dimensional dynamical system, a humanoid in OpenAI Roboschool [5]. The system consists of 50 states with dynamics and a learned controller from OpenAI Roboschool, which takes as input a target position. The obstacles are randomly generated spheres or cubes of random sizes and positions. The initial and goal states too are randomly generated through the state space.

The state is encoded into a four dimensional latent space, which was chosen inspired by [16]

. The network architecture is fully connected. The collision checking network takes as input two latent states and a vector of the centers of each obstacle, the type of obstacle (sphere or cube), and the sphere radius or cube width of the obstacle. The autoencoder and dynamics network was trained on 1,000,000 data points (states and control input), sampled at 10 Hz. This data was obtained by randomly sampling control inputs (target positions) and propagating dynamics with the Roboschool controller

[5], essentially randomly exploring the operational state space. The collision checking network was trained on 1,000,000 data points (pairs of states and the location, type, and size of each obstacle in the workspace).

(a)
(b)
Fig. 6: (5(a)) The humanoid robot with an obstacle in blue and the control target in red. (5(b)) The humanoid robot executing the planned trajectory in the full state space (video at goo.gl/wrm9JR).

Fig. 7 shows the structure learned within the latent space. The latent space captures the intuitively important dynamics of the problem: the robot’s position and yaw. These states most significantly govern the humanoid’s dynamics, i.e., it is often traveling in a straight line towards the control target. The other dimensions of the state space, such as joint angles and velocities, are fairly structured within the gait of the humanoid and only vary small amounts.

(a) center of mass
(b) center of mass
(c) yaw
Fig. 7: A 3D representation of the structure learned within the humanoid latent space, with each plot visualized by the robot’s respectively (where red denotes a low value and blue a high value).

For a single problem, L2RRT for the humanoid (projected into two and three dimensions) is shown in Fig. 8. The latent search is able to remain near the learned manifold, and the collision checker has effectively encapsulated the obstacles. The final trajectory is shown in Fig. 5(b) with the control input (the target location) set as a half second ahead on the planned trajectory. A video is available at goo.gl/wrm9JR. Fig. 9 details L2RRT’s performance in terms of success rate, convergence, and collision network confusion. After only a few hundreds of samples, the algorithm is able to solve 100% of the planning problems. The trajectory cost again shows convergence as the number of samples increases. The collision checking network performs well, classifying nearly 95% correct, with only a 0.7% false positive rate. With 1000 samples, the algorithm takes on average 15 seconds. Note we do not provide comparisons to planning in the full state space as traditional planning approaches with the 50 dimensional, dynamical system are intractable (unlike the visual planning problem where an exact lower-dimensional state was available).

(a) L2RRT in 2D latent space
(b) L2RRT in 3D latent space
Fig. 8: L2RRT in latent space with nodes colored by cost (blue is low cost, red is high cost), collisions are shown in black, and the final trajectory is shown in green.
(a) Success rate
(b) Cost
(c) Collision predictions
Fig. 9: Convergence curves and collision confusion table for the humanoid problem.

Vi Conclusions

We have presented the Latent Sampling-based Motion Planning (L-SBMP) methodology, which leverages the effectiveness of local, latent representations for robotic systems with techniques from sampling-based motion planning (SBMP) to compute motion plans for high-dimensional, complex systems. In particular, this latent space is learned through an autoencoder, a dynamics network, and a separate collision checking network, each of which enforces the main algorithmic primitives of SBMP on the latent space (sampling, local connections, and collision checking). Given this latent space, we use the Learned Latent RRT (L2RRT) algorithm to globally explore the latent space and compute motion plans directly in it. Through two experiments, one planning within visual space and one planning with a humanoid robot, we demonstrate the methodology’s overall generality and ability to generalize to new environments.

This work leaves several avenues for future work. Specific to L-SBMP, we first plan to investigate how much data is required to learn the necessary representation. Second, we plan to investigate learning more restricted classes of dynamics for which a steering function is available, e.g., locally-linear dynamics. This would allow more optimal latent space exploration techniques. Third, we plan to investigate using unsupervised learning to learn the collision checking network. Fourth, we plan to investigate planning problems in which the topology of the latent space is dependent on the environment and obstacle set specific to a planning problem, e.g., if stairs are involved for a humanoid. Fifth, we plan to use a similar methodology within a task and motion planning framework by state augmentation in the full state space. Finally, we plan to investigate conditions under which theoretical guarantees for L2RRT can be derived. Beyond L-SBMP, the approach of learning plannable latent spaces through enforced algorithmic primitives can be quite powerful. We believe a similar methodology could be used to learn a space directly for trajectory optimization, or instead for lower-dimensional problems, combinatorial motion planning.

Acknowledgments

The authors wish to thank Edward Schmerling and Anirudha Majumdar for their helpful discussions on this work.

References