Reducing Collision Checking for Sampling-Based Motion Planning Using Graph Neural Networks
Year: 2022

Abstract:
Sampling-based motion planning is a popular approach in robotics for finding paths in continuous configuration spaces. Checking collision with obstacles is the major computational bottleneck in this process. We propose new learning-based methods for reducing collision checking to accelerate motion planning by training graph neural networks (GNNs) that perform path exploration and path smoothing. Given random geometric graphs (RGGs) generated from batch sampling, the path exploration component iteratively predicts collision-free edges to prioritize their exploration. The path smoothing component then optimizes paths obtained from the exploration stage. The methods benefit from the ability of GNNs of capturing geometric patterns from RGGs through batch sampling and generalize better to unseen environments. Experimental results show that the learned components can significantly reduce collision checking and improve overall planning efficiency in challenging high-dimensional motion planning tasks.

heading: 1 Introduction
text: Sampling-based planning is a popular approach to high-dimensional continuous motion planning in robotics [36, 14, 31, 27, 19, 53, 35]. The idea is to iteratively sample configurations of the robots and construct one or multiple exploration trees to probe the free space, such that the start and goal states are eventually connected by some collision-free path through the sampled states, ideally with path cost minimized. This motion planning problem is hard, theoretically PSPACE-complete [48], and existing algorithms are challenged when planning motions of robots with a few degrees of freedom [34, 15, 1, 39, 9, 15]. In particular, the planning algorithms need to repeatedly check whether an edge connecting two sample states is feasible, i.e., that no state along the edge collides with any obstacle. This collision checking operation is the major computational bottleneck in the planning process and by itself NP-hard in general [28, 7]. For instance, consider the 7D Kuka arm planning problem in the environment shown in Figure 1. The leading sampling-based planning algorithm BIT* [19] spends about 28.6 seconds to find a complete motion plan for the robot, in which 20.2s (70.6% of time) is spent on collision checking. In comparison, it only takes 0.06s (0.2% of time) for sampling all the probing states needed for constructing random graphs for completing the search.
Learning-based approaches have become popular for accelerating motion planning. Many recent approaches learn patterns of the configuration spaces to improve the sampling of the probing states, typically through reinforcement learning or imitation learning [29, 25, 65, 47, 8]. For instance, Ichter et al. [25] and motion planning networks [47] apply imitation learning on collected demonstrations to bias the sampling process. The NEXT algorithm [8] provides a state-of-the-art design for embedding high-dimensional continuous state spaces into low-dimensional representations, while balancing exploration and exploitation in the sampling process. It has demonstrated clear benefits of using learning-based components to reduce samples and accelerate planning. However, we believe two
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
aspects in NEXT can be improved, if we shift the focus from reducing sample complexity to reducing collision checking. First, instead of taking the grid-based encoding of the entire workspace as input, we can use the graphs formed by batches of samples from the free space to better capture the geometric patterns of an environment. Second, having access to the entire graph formed by samples allows us to better prioritize edge exploration and collision checking based on relatively global patterns, and avoid getting stuck in local regions. In short, with reasonably relaxed budget of samples taken uniformly from the space, we can better exploit global patterns to reduce the more expensive collision checking operations instead. Figure 1 shows a typical example of how the trade-off benefits overall planning, and more thorough comparisons are provided in the experimental results section.
(a) (b)Figure 1: Performance on 7D Kuka arm. Left: Trajectory generated by the proposed GNNbased approach. Right: NEXT getting stuck at a local region. Both methods were trained on the same training set. We design two novel learning-based components that utilize Graph Neural Networks (GNNs) to accelerate the search for collision-free paths in batch samplingbased motion planning algorithms. The first component is the GNN Path Explorer, which is trained to find collision-free paths given the environment configuration and a random geometric graph (RGG) formed by probing samples. The second component is the GNN Path Smoother, which learns to optimize the path obtained from the explorer. In both models, we rely on the expressiveness and permutation invariance of GNNs as well as attention mechanisms to identify geometric patterns in the RGGs formed by samples, and accelerate combinatorial search.
The proposed learning-based components can accelerate batch sampling-based planning algorithms without compromising probabilistic completeness properties. The methods achieve higher success rate, much lower rate of collision checking, and accelerate the overall planning compared to state-ofthe-art methods. We evaluate the proposed approach in a variety of planning environments from 2D mazes to 14D dual KUKA arms. Experiments show that our method significantly reduces collision checking, improves the overall planning efficiency, and scales well to high-dimensional tasks.
The paper is organized as follows. We review related work and preliminaries in Section 2 and 3. We describe the detailed design of the GNN architectures in Section 4, followed by the training of GNN explorer and smoother in Section 5. We discuss experimental results in Section 6.

heading: 2 Related Work
text: Learning-based Motion Planning. Learning-based approaches typically consider motion planning as a sequential decision-making problem, which could be naturally tackled with reinforcement learning or imitation learning. With model-based reinforcement learning, DDPG-MP [29] integrates the known dynamic of robots and trains a policy network. Strudel et al. [54] improves the obstacle encoding with the position and normal vectors. OracleNet [2] learns via oracle imitation and encodes the trajectory history by an LSTM [23]. Other than predicting nodes which are expected to greedily form a trajectory, various approaches have been designed to first learn to sample vertices, then utilize sampling-based motion planning for further path exploration through these samples. L2RRT [24] first embeds high-dimensional configuration into low-dimensional representation, then performs RRT [36] on top of that. Ichter et al. [25] uses conditional VAE to sample nodes. Zhang et al. [65] learns a rejection sampling distribution. Madaan [40] encodes the explored tree with an RNN. Motion Planning Networks [47] utilizes the dropout-based stochastic auto-encoder for biased sampling. NEXT [8] projects the high-dimensional planning spaces into low-dimensional embedding discrete spaces, and further applies Gated Path Planning Networks [37] to predict the samples.
Existing learning-based approaches have considered improving collision detection. Fastron [13] and ClearanceNet [6] learn function approximators as a proxy to collision detection, which is disparate from our focus on reducing the steps that are needed to the collision checker, and can be improved further potentially if combined together. Another recent line of work focuses on learning to explore edges given fixed graph. Value Iteration Networks [55] and Gated Path Planning Networks [37] apply convolutional neural networks (CNN) on discrete maps, then predict the policy with a weighted attention sum over neighborhoods. Generalized Value Iteration Networks [44] and Velickovic et al.
[60] extend this approach for nontrivial graph by replacing CNN with GNN. However, the construction of such graphs requires ground-truth collision status for every edge on the graph at inference time.
It should be noted that other than sampling-based approaches, trajectory optimization [30, 68, 57, 51, 67], and motion primitives [43, 66] are standard choices for more structured problems such as for autonomous cars and UAVs, while sampling-based methods are important for navigating high-dimensional cluttered spaces such as for manipulators and rescue robots.
Graph Neural Networks for Motion Planning. Graph neural networks are permutation invariant to the orders of nodes on graph, which become a natural choice for learning patterns in graph problems. They have been successfully applied in robotics applications such as decentralized control [38]. For sampling-based motion planning, Khan et al. [33] utilizes GNN to identify critical samples. We focus on the different aspect of collision checking with given random geometric graphs, and can be combined with existing techniques without affecting probabilistic completeness. More broadly, GNNs have been used for learning patterns in general graph-structured problems, e.g. graph-based exploration [12, 52], combinatorial optimization [32, 16, 5], neural algorithm execution [60, 61, 63, 59]. Other than to use GNN for high-dimensional planning, several works propose to first learn neural metrics, then build explicit graphs upon the learned metric which is used later to search the path [50, 18, 17, 64]. While sharing similar interests, our work specifically focuses on how to reduce the collision checking steps for sampling-based motion planning.
Informed Sampling for Motion Planning. A main focus in motion planning is on developing problem-independent heuristic functions for prioritizing the samples or edges to explore. Approaches include Randomized A* [14], Fast Marching Trees (FMT*) [27], Sampling-based A* (SBA*) [45], Batch Informed Trees (BIT*) [19]. These methods are orthogonal to our learning-based approach, which can further exploit the problem distribution and recognize patterns through offline training to improve efficiency. Recent work in motion planning has made significant progress in reducing collision checking through batch sampling and incremental search, such as in BIT* [19] and AIT* [53]. The idea is to start with batches of probing random samples in the free space, and focus on reducing collision checking to edges that are likely on good paths to the goal, which also inspires our work.
Lazy Motion Planning. Lazy motion planning also focuses on reducing collision checking, typically with hand-crafted heuristics or features. LazyPRM and LazySP [4, 21] construct an RGG first and check the edge lazily only if that edge is on the global shortest path to the goal. Instead of calculating a complete shortest path, LWA* uses one-step lookahead to prioritize certain edges [11]. LRA* interleaves between LazySP and LWA*, with a predefined horizon to lookahead [41]. These approaches use hand-crafted heuristics and do not utilize data-dependent information from specific tasks. Recently, GLS and StrOLL [42, 3] leverage experiences to learn to select the edge to check with either fixed graphs or hand-crafted features. Our GNN-based approach proposes the use of new representations for the learning-based components, with the goal of directly recognizing patterns using samples from the configuration space.

heading: 3 Preliminaries
text: Motion Planning. We focus on motion planning in continuous spaces, where the configuration space is C ⊆ Rn. The configuration space includes all degrees of freedom of a robot (e.g. all joints of a robotic arm) and is different from the workspace where the robot physically resides in, which is at most 3-dimensional. For planning problem on a graph G = 〈V,E〉, we denote the start vertex and goal vertex as vs, vg ∈ C. A path from vs to vg is a finite set of edges π = {ei : (vi, v′i)}i∈[0,k] such that v0 = vs, v′k = vg, and v ′ i = vi+1 for all i ∈ [0, k − 1]. An environment for a motion planning problem consists of a set of obstacles Cobs ⊆ C and free space Cfree = C \ Cobs. Note that Cobs is the projection of 3D objects in the higher-dimensional configuration space, and typically has complex geometric structures that can not be efficiently represented. A sample state v ∈ C in the configuration space is free if v ∈ Cfree, i.e., it is not contained in any obstacle. An edge connecting two samples is free if e ⊆ Cfree. Namely, for every point v on the edge e, v ∈ Cfree. A path π is free if all its edges are free. A random geometric graph (RGG) is a r-disc or k-nearest-neighbor (k-NN) graph G [20, 62], where nodes are randomly sampled from the free space Cfree. In this paper we consider the RGG as a k-NN graph. Given a random geometric graph G and a pair of start and goal configuration (vs, vg), the goal of agent is to find a free path π from vs to vg. Without loss of generality, we consider the cost of a path to be the total length over all edges in it.
Graph Neural Networks and Attention. Let G = 〈V,E〉 be a finite graph where each vertex vi is labeled by data xi ∈ Rn. A graph neural network (GNN) learns the representation hi of node vi by aggregating the information from its neighbors N (vi). Given fully-connected networks f and g, a typical GNN encodes the representation h(k+1)i of the node vi after k aggregation as:
c (k) i = ⊕
(k)( { f(h
(k) i , h (k) j ) | (vi, vj) ∈ E } ) and h(k+1)i = g(h (k) i , c (k) i ) (1)
where h(1)i = xi and ⊕ is some permutation-invariant aggregation function on sets, such as max, mean, or sum. We will also use the attention mechanism when we need to encode a varied number of obstacles as inputs. Suppose there are n keys each with dimension dq: K ∈ Rn×dk , each key corresponding to a value V ∈ Rn×dv . Given m query vectors Q ∈ Rm×dk , we use a typical attention function Att(K,Q, V ) for each query as Att(K,Q, V ) = softmax(QKT / √ dk)V [58]. The function is also permutation-invariant so the order of obstacles does not affect the output.

heading: 4 GNN Architecture for Path Exploration and Smoothing

heading: 4.1 Overall Approach
text: At a high level, motion planning with batch sampling typically proceeds as follows [19]. We first sample a batch of configurations in the free space, together with the start and goal states, and form a random graph (RGG) by connecting neighbor states (such as k-NN). A tree is then built in this graph from the start towards the goal via heuristic search. The tree can only contain collision-free edges, so each connection requires collision checking. When a path from start to goal is found, it is stored as a feasible plan, which can be later updated to minimize cost. After adding all collision-free edges in the current batch in the tree, a new batch will be added and the tree is further expanded. The algorithm keeps sampling batches and expanding the tree until the computation budget is reached. It then returns the best path found so far, or failure if none has been found.
We use GNN models to improve two important steps in this planning procedure: path exploration and path smoothing. The GNN path explorer finds a feasible path π from start to goal given a randomly batch-sampled RGG, with the goal of reducing the number of edges that need to be checked for collision. The GNN path smoother then takes the path found by the explorer and attempts to produce another feasible path with less cost. In both tasks, the GNN models aim to recognize patterns and learn solutions to the combinatorial problems and save computation. In Figure 2, we illustrate the main steps for the overall algorithm. First, in (a-c), we generate an RGG composed of the vertices randomly sampled from the free space without collision checking on edges. This graph will provide patterns that the GNN explorer later uses to only prioritize certain edges for collision checking. In (d), the graph is the input to the GNN path explorer, which predicts the priority of the edges to explore and only the proposed edges are checked for collision. (e): We iteratively query the path explorer with collision checking to expand a tree in the free space until the goal vertex is reached, and sample new batches when no path is found in the current graph. (f): Once a path is provided by the path explorer, it becomes the input (together with the current RGG) to the GNN path smoother component, which outputs a new path that reduces path cost via local changes to the vertices in the input path.

heading: 4.2 GNN Architecture
text: We write the GNN path explorer as NE and the GNN path smoother as NS . Both models take in a sampled random geometric graph G = 〈V,E〉. For an n-dimensional configuration space, each vertex vi ∈ Rn+3 contains an n-dimensional configuration component and a 3-dimensional one-hot label. There are 3 kinds of labels for the explorer: (i) the vertices in the free space, (ii) the vertices with collision, and (iii) the special goal vertex. There are also 3 kinds of labels for the smoother: (i) the vertices on the path, (ii) the vertices in the free space, and (iii) the vertices with collision.
The vertices and the edges are first embedded into a latent space with x ∈ R|V |×dh , y ∈ R|E|×dh , where dh is the size of the embedding. The embeddings for the GNN explorer and smoother are different, which will be discussed later in this section. Taking the vertex and edge embedding x, y, the GNN aggregates the local information for each vertex from the neighbors, by performing the
following operation with 2 two-layer MLPs fx and fy:
xi = g (xi,max{fx(xj − xi, xj , xi, yl) | el : (vi, vj) ∈ E}) ,∀vi ∈ V yl = max(yl, fy(xj − xi, xj , xi)),∀el : (vi, vj) ∈ E
(2)
Note that here we use max as the aggregation operator to gather the local geometric information, due to its empirical robustness to achieve the order invariance [46]. The edge information is also incorporated by adding yl as the input to fx. The update function g is implemented in two different ways for the GNN explorer and smoother. Specifically, g equals to the max operator for the GNN explorer, and g(mi, xi) = fg(mi) + xi as the residual connection for the GNN smoother, where fg is a two-layer MLP. We choose max operator for the explorer, due to its inductive bias to imitate the value iteration, as mentioned by Velickovic et al. [60]. The residual connection is applied to the smoother, since intuitively the residual provides a direction for the improvement of each node on the path in the latent space, which fits our purpose to generate a shorter path for the smoother.
We also note that Equation 2 directly updates on the x and y and is a homogeneous function similar to Tang et al. [56], which allows us to self-iterate x and y over multiple loops without introducing redundant layers. Both the GNN explorer and smoother leverage this property. After several iterations, with two MLPs fη , fu,NE outputs the priority η = fη(y) for each edge, andNS outputs a potentially shorter path π′ = {ui, u′i}, ui = fu(xi) for vi ∈ π.
Special design for the GNN path explorer. The path explorer uses the embedding of the vertices of the form x = hx(v, vg, (v−vg)2, v−vg), where hx is a two-layer MLP with batch normalization [26]. Here we append the L2 distance and the difference to the goal to the vertex embedding, which serve as heuristics for the GNN to be more informed about which node is more valuable. The yl is simply computed as yl = hy(vj − vi, vj , vi), where hy is also a two-layer MLP with batch normalization. Optionally, it is helpful for the explorer to incorporate the configuration of obstacles O = {o} ∈ R|{o}|×2n as inputs, when embedding the vertices and edges. Since the obstacles of the environment has variable numbers, we utilize the attention mechanism here to update the x and y, named as obstacle encoding, as illustrated in Figure 2. Further details are provided in the Appendix.
Special design for GNN path smoother. The GNN smoother embeds vertices with x = hx(v), where hx is a two-layer MLP with batch normalization. The yl is computed as yl = hy(vj−vi, vj , vi), where hy is a two-layer MLP with batch normalization. Each time x and y are updated by Equation 2, the GNN smoother will output a new smoother path π′ = {(ui, u′i)}i∈[0,k] , where ui = fu(xi),∀vi ∈ π, given an MLP fu. The u0 and u′k are manually replaced by vs and vg , to satisfy the path constraint. We assume the π′ has the same number of nodes as π. Since the GNN smoother could gain novel local geometric information with the changed vertices of the new path, we dynamically updateG = 〈V,E〉, via (i) replacing those nodes labeled as path nodes in V by the nodes on new path, (ii) replacing E by generating a k-NN graph on the updated V . With the updated graph G, we repeat the above operation. During training, the GNN smoother outputs π′, after a random number of iterations (between 1 and 10). During evaluation, the GNN smoother outputs π′ after only one loop for each calling.

heading: 5 Training the Path Explorer and Smoother
text: Due to space limitation we provide the pseudocode for all algorithms in the Appendix.
5.1 GNN Explorer NE: Training and Inference
The path explorer constructs a tree through sampled states with the hope of reaching the goal state in a finite number of steps. We initialize the tree T0 with the start state vs as its root. Every edge eTi in the tree Ti exists only if eTi is in the free space Cfree. Given an RGG G = 〈V,E〉, Our goal is to find a tree containing the goal configuration vg by adding edges from E to the tree, with as few collision checks as possible. We write the edge on frontier of the tree as Ef (T ) = {(vi, v′i) | vi ∈ VT , v ′ i 6∈ VT }. We denote the set of edges with unknown collision status at time step i as Ei.
Training procedures. Each training problem consists of a set of obstacles O, start vertex vs, goal vertex vg, we sample a k-NN graph G = 〈V,E〉, where V is the random vertices sampled from the free space combined with {vs, vg}. The goal is to train NE to predict exploration priority η ∈ R|E|. A straightforward way for supervision is to use the Dijkstra’s algorithm to compute the shortest feasible path from vs to vg, and maximize the corresponding values of η at the edges of this path, via cross entropy loss or Bayesian ranking [49]. However, it does not provide useful guidance when the search tree deviates from the ideal optimal path at inference time. Instead, we first explore the graph using η with i steps, which forms a tree Ti, where i is a random number. The oracle provides the shortest feasible path πN in this tree and connects one of the nodes on Ti to the goal vertex vg. We formulate this optimal path as πN = {eNi : (vNi , v′Ni)}i∈[0,k], where vN0 ∈ VTi , v ′ Nk
= vg . We train the explorer to imitate this oracle. Namely, the explorer will directly choose eN0 ∈ πN as the next edge to explore, among all possible edges on the frontier of Ti, i.e. Ei ∩ Ef (Ti). We maximize the ηN0 among the values of {ηi | ei ∈ Ei ∩ Ef (Ti)} using the following cross entropy loss:
LNE = − log γN0 , where γk = eηk∑
ej∈Ei∩Ef (Ti) e ηj ,∀ek ∈ Ei ∩ Ef (Ti) (3)
Inference procedures. Given the GNN NE , the current explored tree Ti at step i, the RGG G = 〈V,E〉 including vs and vg , environment configuration O, GNN path explorer aims to maximize the probability of generating a feasible path by adding ei from Ei to tree Ti as:
ei = argmax ek∈Ei∩Ef (Ti)
NE(ηk | V,E,O) (4)
where ηk is the output of NE for the edge ek. After ei is proposed by GNN using Equation 4, we check the collision of ei. If ei is not in collision with the obstacles, we add the edge ei to the tree Ti, and remove ei from Ei, i.e., ETi+1 = ETi ∪ {ei}, and Ei+1 = Ei \ {ei}. If ei is in collision with obstacles, we query the path explorer for the next proposed edge using Equation 4, where Ei is updated as Ei = Ei \ {ei}. The loop terminates when we find a collision-free edge, or when Ei ∩Ef (Ti) = ∅. When the latter happens, we re-sample another batch of samples, add new samples to vertices V , re-construct k-NN graph G, re-compute η, and continue to explore the path on this new graph with the explored nodes and edges.
The exploration GNN only proposes an ordering on the candidate edges, and all possible edges may still be collision checked in the worst case. Thus, if there exists any complete path in the RGG, the algorithm always finds it. Therefore, the proposed learning-based component does not affect the probabilistic completeness of sampling-based planning algorithms [10].
5.2 GNN Path Smoother NS: Training and Inference
The GNN NS for path smoothing takes an RGG and a path π proposed by the explorer, and aims to produce a shorter path π′. Specifically, the input is a graph G = 〈V,E〉, where V = Vπ ∪ Vf ∪ Vc, E = Eπ ∪ Efc. Here, Vf and Vc are reused as the same vertices in the GNN explorer, without introducing extra sampling complexity. Eπ is composed of those pairs of the adjacent vertices on π, and Efc connects each vertex in Vπ to their k-nearest neighbor in Vf ∪ Vc. Intuitively, aggregating information from Vf∪Vc can allow GNN to identify local regions that provide promising improvement on the current path, and avoid those that may yield potential collision.
Training procedures. We train the GNN path smoother NS by imitating a smoothing oracle S similar to the approach of gradient-informed path smoothing proposed by Heiden et al. [22]. To prepare the training set, we iteratively perform the following two operations on each training sample path. Given a feasible path π predicted by NE , the smoothing oracle first tries to move the nodes on the path π with perturbation within range . If the new path πM is feasible and has cost less than π, then S will continue to smooth on πM . Otherwise, S will continue smoothing on π via random perturbation. After several perturbation trials, the oracle further attempts to connect pairs of nonadjacent nodes directly by a line segment. If such a segment is free of collision, then the original intermediate nodes will be moved on this linear segment. Further details are in the Appendix.
After S reaches maximum iteration, the oracle will return the smoothed path πM = {wi, w′i}i∈[0,k]. To generate training data, we first run our trained GNN explorer for each training problem to get the initial path π. Then the oracle path πM and the predicted path π′ are computed, and finally the GNN is trained via minimizing the MSE loss LNS = 1 k ∑ i∈[1,k] ‖NS (ui | V,E)− wi‖22.
Inference procedures. The GNN NS for path smoothing takes an explored path π : {(vi, v′i)}i∈[0,k], a sampled graph G, and outputs a potentially shorter path π′ : {(ui, u′i)}i∈[0,k] which has the same number of edges as π. It is not always guaranteed that π′ is collision-free. However, such π′ still indicates directions for shortening the path, so we can improve π towards π′ in an incremental way. The GNN smoother will try to move every node vi towards the target position ui, with a small step size . For each time that all the vertices are moved with a small step, we check whether each edge still holds collision-free. If not, then the vertices on the edge will undo the movement. Otherwise, the new configuration of the vertex will replace its old configuration on π. This operation will be
iterated over several times, until the maximum iteration is reached, or no edges on π can be moved further. We can then repeat the process by feeding the updated π back to the GNN NS for further improvement. The intuition here is that there might still be chances to improve upon the updated π, by aggregating new information from its changed neighborhoods. This has shown empirical advantage in our experiments.

heading: 6 Experiments

heading: 6.1 Overall Performance
text: We compare our methods with the sampling-based planning baseline RRT* [31], the state-of-the-art batch-sampling based method BIT* [19], the lazy motion planning method LazySP [21], and the state-of-the-art learning-based method NEXT [8]. NEXT has been shown in [8] to outperform competing learning-based approaches. We conduct the experiments on the following environments: (i) a 2D point-robot in 2D workspace, (ii) a 6D UR5 robot in a 3D workspace, (iii) a 7D snake robot in 2D workspace (the z-axis is fixed), (iv) a 7D KUKA arm in a 3D workspace, (v) an extended 13D KUKA arm in 3D workspace, (vi) and a pair of 7DoF KUKA arms (14 DoF) in 3D workspace.
For each environment, we randomly generate 2000 problems for training and 1000 problems for testing. Each problem contains a different set of random obstacles, and a pair of feasible vs and vg. We run all experiments over 4 random seeds. The averaged results are illustrated in Figure 5. For the 2D environment, we directly take the training set provided by NEXT to train our GNN. We use two test sets for the 2D environment: “Easy2D" is the original test set used for evaluating NEXT in the original paper [8], and “Hard2D" is a new set of tests we generated by requiring the distance between the start and goal to be longer than the easy environments. The goal is to test whether the learned models can generalize to harder problems without changing the training set. Further details on the environments and hyperparameters are provided in the Appendix.
Easy2D H ard2D U R5 Snake Kuka7D 13D 14D
0
1000
2000
3000
4000
5000
6000
Collision Check
Easy2D H ard2D U R5 Snake Kuka7D 13D 14D
0
2
4
6
8
10
12
14
16
Path Cost
Easy2DHard2D UR5 Snake Kuka7D 13D 14D
0
0.2
0.4
0.6
0.8
1 Success Rate
Easy2DHard2D UR5 Snake Kuka7D 13D 14D
100
1e+3
1e+4 Total Time (seconds)
0.2
0.4
0.6
0.8
1 Success Rate
Easy2DHard2D UR5 Snake Kuka7D 13D 14D
0
0.2
0.4
0.6
0.8
1 Success Rate
Easy2DHard2D UR5 Snake Kuka7D 1 D 1 D
0
0.2
0.4
0.6
0.8
1 Success Rate
2D Easy 0
1
2
3
4
5
GNN
GNN + Smoother
GNN w/o Obstacle Encoding
GNN w/o Obstacle Encoding + Smoother
BIT*
NEXT
RRT* Ru nn
in g
Ti m
e
2D Easy
0
1
2
3
/ t l i
/o bstacle Encoding + S oother
BIT*
NEXT
RRT* Ru nn
in g
Ti m
e
2D Easy 0
1
2
3
4
5
GNN
GNN + Smoother
GNN w/o Obstacle Encoding
GNN w/o Obstacle Encoding + Smoother
BIT*
NEXT
RRT* Ru
nn in
g Ti
m e
2 Easy 0
Ru nn
in g
Ti m
e
2D Easy 0
1
2
3
4
5
GNN
GNN + Smoother
GNN w/o Obstacle Encoding
GNN w/o Obstacle Encoding + Smoother
BIT*
NEXT
RRT* Ru nn
in g
Ti m
e
2D Easy 0
1
2
3
4
5
GNN
GNN + Smoother
GNN w/o Obstacle Encoding
GNN w/o Obstacle Encoding + Smoother
BIT*
NEXT
RRT* Ru nn
in g
Ti m
e
2D Easy 0
1
2
3
4
5
GNN
GNN + Smoother
GNN w/o Obstacle Encoding
GNN w/o Obstacle Encoding + Smoother
BIT*
NEXT
RRT* Ru nn
in g
Ti m
e
Easy2D
0.1
1
(Explorer Only)
other
/ stacle Encoding
/ stacle Encoding + Sm other
I
RRT*
LazySP*
Running Time (seconds)
Figure 5: Comparison of performances on all environments from 2D to 14D, averaged over 4 random seeds. From left to right: (a) Success rate. (b) Collision checks. (c) Path cost. (d) Total planning time.
Figure 6: We test the generalization capability of GNN-based approaches and NEXT by constructing pairs of problems that have small but important difference in connectivity. The GNN models find paths on both environments quickly, while NEXT gets stuck in hard instances because of the lack of access to the graph structure provided by probing samples. The explored vertices of GNN on UR5 environment are colored in blue, and the edges on the path are colored in red.
Success rate. As shown in Figure 5 (a), our method finds complete paths at 100.0% problems on both 2D Easy and 2D Hard, and at 97.18%, 99.85%, 99.20%, 99.15%, and 99.15% problems from UR5 to 14D, which is comparable to handcrafted heuristics used in BIT* (100.0%, 100.0%, 99.25%, 99.85%, 99.65%, 99.92%, 99.82% on each environment). The learning-based planner NEXT performs well on easy 2D problems (99.37% success rate), but drops slightly to 97.10% on harder 2D problems, and 36.80%, 71.80%, 87.9%, 60.52%, 66.57% on environments in higher dimensions.
Collision checking. In Figure 5 (b), we see significant reduction of collision checking using the proposed approach, in comparison to other approaches especially in high-dimensional problems. The average number of collision checks by the GNN explorer is 336.3, 715.7, 2474.0, 1602.2, 350.5, 521.7, 487.0 on the environments, whereas BIT* needs 112%, 175%, 164%, 101%, 557%, 226%, 263% times as many collision checks as our method requires on each environments. LazySP needs 105%, 114%, 111%, 100%, 105%, 105%, 124% times as many collision checks as GNN requires on each environments. NEXT requires 270.23 checks on Easy2D and increases to 1206.1 on Hard2D. On the 14D environment, our method uses 17.4% of the collision checks as what NEXT requires.
Path cost. We show the average path cost over all problems where all algorithms successfully found complete paths. With the smoother and obstacle encoding, our GNN approach provides the best results from UR5 to 14D, and generates comparable results for the 2D Easy and 2D Hard, where NEXT is 1.02, 1.71, and GNN is 1.18, 2.05. We find that although the GNN explorer does not yield shorter path with obstacle encoding, these explored paths can be improved further with the smoother. The reason may be that with additional obstacle encoding, the GNN explorer tends to explore edges with less probability of collision and provides more space for the smoother to improve the paths.
Planning time. A common concern about learning-based methods is that their running cost due to the frequent calling of a large neural network model at inference time (as seen for the NEXT curve). We see in Figure5(d) that the wall clock time of using the GNN models is comparable to the standard heuristic-based LazySP, BIT* and RRT*, when all algorithms can find paths. The main reason is that the reduction in collision checking significantly reduces the overall time. We believe the GNNs can be further optimized to achieve faster inference as well.
In summary, experimental results show that the GNN-based approaches significantly reduce collision checking while maintaining high success rate, low path cost, and fast overall planning. The performance scales well from low-dimensional to high-dimensional problems.

heading: 6.2 Generalizability of Collision Reduction
text: A major challenge of learning-based approaches for planning is that small changes of the geometry of the environment can lead to abrupt change in the solutions, and thus lead the difficulty of generalization. In Figure 6, we provide evidence that the GNN approach can alleviate this problem because of its access to the graph structures formed by samples uniformly taken from the space. In the 2D maze environment, the top one is easy while the bottom one is much harder, although the difference is just whether a narrow corridor is present to the left of the start state. For the UR5 with pads and poles, to solve the hard one, the robot arm needs to first rotate itself around the z-axis to bypass the small pads, and then rotate it back to fit the goal configuration. These problems are especially challenging for generalizing learned results to unseen environments.
We observe that the GNN-based components can handle the transition from the easy to hard problems consistently. In both environments, the GNN components find paths quickly, with 9 and 236 edges explored for 2D maze, and with 1 and 256 edges explored for UR5. In contrast, the NEXT model trained on the same training sets, can quickly find a path in the easy problem, but gets stuck in the hard one. Since the two problems are close to each other in the input space for NEXT, it is not surprising to see this difficulty of generalization. In fact, the only case where NEXT can eventually find a path on 2D Maze after more than 6K edge exploration is when the algorithm delegates 10% operations to standard RRT*. Without delegating to RRT*, NEXT gets stuck in local regions after 10K exploration steps on 2D and 1K steps on UR5.

heading: 6.3 Further Comparison with Lazy Motion Planning
text: We compare GNN with the lazy motion planning method LazySP [21]. Lazy approaches prioritize the collision checking on edges that are part of the shortest paths in the RGG, which is a strategy that can often see good performance especially on randomly generated graphs. However, as lazy planning uses the fixed heuristic of prioritizing certain paths, it is easy to come up with environments where
this heuristic becomes misleading. Our proposed learning-based approach, instead, uses GNN to discover patterns from the training set, and can thus be viewed as a data-dependent way of forming heuristics for reducing collision checking.
Consider U-shaped obstacles, with the start state close to the bottom of the U-shape, as shown in Figure 7. It is a standard environment that is particularly hard for the standard lazy approach, which prioritize the edges that directly connect the start and goal states, as they are close in the RGG that does not consider obstacles. Indeed, the lazy approach needs to check most of the edges that cross the obstacles before the path for getting out of the U-shape can be found. We train the GNN-based model on these environments and observe clear benefits of learning-based components in avoiding this issue. Figure 7 shows the difference between the two approaches in several examples of the 2D environment using different sizes of sample batches, where the GNN-based approach can typically save 50% of collision checking on edges compared to the lazy approach.
6.4 Ablation Study: Probing Samples
2 0 0 4 0 0 6 0 0 8 0 0 1 0 0 0
2
2
0
0
4
0
0
6
0
0
8
0
0
1
0
0 0
2 0 0 4 0 0 6 0 0 8 0 0 1 0 0 0
0
0
0
0
0
0
10 2D Easy 2D Hard
2 0 0 4 0 0 6 0 0 8 0 0 1 0 0 0
We perform ablation studies of varying different parameters in our approach. The full details are provided in the Appendix. For instance, we use RGGs with different number of vertices from the free space, using 100, 200, 300, 500, 1000 samples, as illustrated in Figure 8. The success rate increases when there are more probing samples, which is consistent with the resolution-complete property of sampling-based planning. The path cost stays nearly the same for all settings, indicating robustness of the smoother models. The collision checks and planning time grows linearly with the probing samples. The reason is that the number of edges of k-NN RGG increments linearly with vertices, the input to the GNN grows linearly, thus the computation cost increases linearly on both CPU and GPU.

heading: 7 Conclusion
text: We presented a new learning-based approach to reducing collision checking in sampling-based motion planning. We train graph neural network (GNN) models to perform path exploration and path smoothing given the random geometric graphs (RGGs) generated from batch sampling. We rely on the ability of GNN for capturing important geometric patterns in graphs. The learned components can significantly reduce collision checking and improve overall planning efficiency in complex and high-dimensional motion planning environments.
Acknowledgments and Disclosure of Funding
This material is based upon work supported by the United States Air Force and DARPA under Contract No. FA8750-18-C-0092, AFOSR YIP FA9550-19-1-0041, NSF Career CCF 2047034, and NSF NRI 1830399. We thank the anonymous reviewers for various important suggestions, such as for the comparison with lazy planning approaches.

Review summaries:
At a high-level, this work proposes GNNs as models for biasing the sampling of edges and nodes to connect in a random geometric graph. The chief goal is to reduce the amount of collision-checking necessary to plan a path from a start to a goal. Two models are presented: one that performs the above, and another that then smooths the returned path in order to further reduce path cost.  Specifically, the proposed approach first constructs a random geometric graph (RGG) by sampling points from free space. Then, a GNN-parameterized policy iteratively guides the selection of RGG edges for collision-checking. A collision-free path is found when the start and goal nodes are connected on the RGG. The algorithm then leverages another GNN to smooth the solution path. Both GNNs are learned by imitating the solutions of existing oracles. The proposed approach achieves higher success rates, lower collision checks, and comparable path costs on a set of benchmark motion planning tasks compared to existing traditional and learning-/sampling-based algorithms.

This paper proposes a learning-based algorithm for reducing the planning time for collision-free robot motion planning problems. The author rightly notes that the bottleneck for motion planning is collision checking, especially along the vertices on the edges of a search tree, and proposes to learn a function, called GNN Path Explorer, that prioritizes the edges to check collisions. Based on this priority information, the algorithm builds a path from a start to a goal, while checking collisions only on the edges that have the highest priority out of the ones that have not been considered so far. This tree is then fed to a GNN Path Smoother, which processes the path and modifies it to one that has a lower cost. Training data is generated by past planning experience, in which the oracle is used to compute the optimal path on the current search tree. It is demonstrated on several domains, ranging from 2D environments with narrow passages and a point robot, to domains with high dimensional configuration spaces (c-space).