SLOPE: Search with Learned Optimal Pruning-based Expansion

TL;DR

SLOPE tackles the memory and computation bottlenecks of heuristic search for path planning by learning a node-specific distance to the nearest optimal path $d(n)$ and pruning nodes with low scores. It builds a dataset of optimal-path regions and trains a regressor $d_{ML}(n)$ to guide pruning, introducing two pruning algorithms, SLOPE and SLOPEr, that use a threshold to control exploration while preserving completeness. Across grid-domain experiments, SLOPE variants achieve comparable or better node expansion and substantially smaller Open lists, and can operate standalone or in conjunction with learned cost-to-go heuristics, though results depend on map structure and threshold choices. The work highlights a flexible, orthogonal approach to improving search efficiency with potential extensions to larger maps and more advanced learning architectures.

Abstract

Heuristic search is often used for motion planning and pathfinding problems, for finding the shortest path in a graph while also promising completeness and optimal efficiency. The drawback is it's space complexity, specifically storing all expanded child nodes in memory and sorting large lists of active nodes, which can be a problem in real-time scenarios with limited on-board computation. To combat this, we present the Search with Learned Optimal Pruning-based Expansion (SLOPE), which, learns the distance of a node from a possible optimal path, unlike other approaches that learn a cost-to-go value. The unfavored nodes are then pruned according to the said distance, which in turn reduces the size of the open list. This ensures that the search explores only the region close to optimal paths while lowering memory and computational costs. Unlike traditional learning methods, our approach is orthogonal to estimating cost-to-go heuristics, offering a complementary strategy for improving search efficiency. We demonstrate the effectiveness of our approach evaluating it as a standalone search method and in conjunction with learned heuristic functions, achieving comparable-or-better node expansion metrics, while lowering the number of child nodes in the open list. Our code is available at https://github.com/dbokan1/SLOPE.

Figures (3)

• Figure 1: Visualizations of the steps of our method on several map types- forest, bugtrap+forest, maze and single bugtrap. The visualization elements are: map (upper left square), expanded nodes of our algorithm (upper right), dataset ground truth optimal areas (lower left) and model estimation of optimal areas (lower right).
• Figure 2: Learned optimality regions of a fully-sized 200x200 map. This model serves as a proof of concept, and as such was trained for 10 epochs on 100 maps, noticeably lower than our downscaled experiments.
• Figure 3: Visualization of the different approaches by the cost-to-go model (upper row) and $d_{ML}$ (lower row). The visualization of the cost-to-go model shows the model leaning towards the path under the bugtrap, while $d_{ML}$ is blocking that approach and taking the path above it. Combining the two, that are individually both sound, gives an in-between mix that is worse than both.