A-MHA*: Anytime Multi-Heuristic A*

TL;DR

This paper introduces A-MHA*, an extension of Multi-Heuristic A* that operates as an anytime algorithm, quickly finding and continually improving suboptimal solutions in complex path planning and puzzle domains.

Contribution

It extends MHA* to an anytime framework inspired by ARA*, maintaining guarantees while enabling iterative solution improvement.

Findings

A-MHA* finds feasible solutions rapidly in tested domains.

It outperforms original MHA* and other anytime algorithms in efficiency.

The approach preserves suboptimality and completeness guarantees.

Abstract

Designing good heuristic functions for graph search requires adequate domain knowledge. It is often easy to design heuristics that perform well and correlate with the underlying true cost-to-go values in certain parts of the search space but these may not be admissible throughout the domain thereby affecting the optimality guarantees of the search. Bounded suboptimal search using several such partially good but inadmissible heuristics was developed in Multi-Heuristic A* (MHA*). Although MHA* leverages multiple inadmissible heuristics to potentially generate a faster suboptimal solution, the original version does not improve the solution over time. It is a one shot algorithm that requires careful setting of inflation factors to obtain a desired one time solution. In this work, we tackle this issue by extending MHA* to an anytime version that finds a feasible suboptimal solution quickly and continually improves it until time runs out. Our work is inspired from the Anytime Repairing A* (ARA*) algorithm. We prove that our precise adaptation of ARA* concepts in the MHA* framework preserves the original suboptimal and completeness guarantees and enhances MHA* to perform in an anytime fashion. Furthermore, we report the performance of A-MHA* in 3-D path planning domain and sliding tiles puzzle and compare against MHA* and other anytime algorithms.

Tables

Table 1. Table 1: Average statistics for 50 instances of 63 tile sliding puzzle: T i ​ n ​ i ​ t ​ i ​ a ​ l T_{initial} - Time to produce the first solution; T f ​ i ​ n ​ a ​ l T_{final} - Time to produce the final solution; ϵ i ​ n ​ i ​ t ​ i ​ a ​ l \epsilon_{initial} - Reported Initial suboptimality bound; ϵ f ​ i ​ n ​ a ​ l \epsilon_{final} - Reported final suboptimality bound.

Metric	A-MHA*	ARA*	ANA*	MHA*
Success rate	88.24	70.59	44.18	88.24
$T_{initial}$	9.69	18.99	23.13	9.69
$T_{final}$	39.70	29.82	41.73	9.69
${ϵ}_{initial}$	25	25	3.58e+07	25
${ϵ}_{final}$	4	5.1667	3.31	25

Table 2. Table 2: Average statistics for 50 instances of 48 tile sliding puzzle: T i ​ n ​ i ​ t ​ i ​ a ​ l T_{initial} - T i ​ n ​ i ​ t ​ i ​ a ​ l T_{initial} - Time to produce the first solution; T f ​ i ​ n ​ a ​ l T_{final} - Time to produce the final solution; ϵ i ​ n ​ i ​ t ​ i ​ a ​ l \epsilon_{initial} - Reported Initial suboptimality bound; ϵ f ​ i ​ n ​ a ​ l \epsilon_{final} - Reported final suboptimality bound.

Metric	A-MHA*	ARA*	ANA*	MHA*
Success rate	100	75	75	100
$T_{initial}$	17.51	15.05	42.41	17.51
$T_{final}$	42.90	31.075	111.42	17.51
${ϵ}_{initial}$	25	25	2.95e+07	25
${ϵ}_{final}$	7.33	8.77	7.90	25

Full text

Introduction

Real world and real-time planning requires utilizing the limited amount of time available to find a solution that is as close as possible to the optimal one. To that end, anytime algorithms have been developed that can generate a quick suboptimal solution and keep improving it over time. In addition, it is vital to know the quality of such intermediate solutions to decide whether to continue running the planner or to terminate it. Bounded suboptimal search algorithms deals with this problem and provides guarantees on the solution cost. Informed search or heuristic search is an important subclass of these search algorithms that employ underestimates of the true cost-to-go called heuristics to ensure completeness and find bounds on the solution quality. In order to obtain such quantifiable solutions, these heuristics have to satisfy critical properties called admissibility and consistency for all the states in the entire search space. However, crafting heuristics that can obey those properties for large state spaces and high-dimensional planning problems are incredibly hard.

In many real world scenarios, it is often easy to deduce heuristics that aims to partially solve the bigger problem in hand. Multi-Heuristic A* (?) is a recent work that tries to combine such arbitrarily inadmissible heuristics to speed up the search while ensuring strong guarantees. It needs the user to specify the desired suboptimality factor of the output solution prior to beginning the search. This is an extremely tricky step as one requires thorough domain knowledge to strike a balance between runtime and solution quality. In the absence of such domain knowledge, an anytime planner that can rapidly find a low quality solution and steer towards asymptotic convergence is preferred. However, this class of planners can provide guarantees only with consistent heuristics. Anytime Multi-Heuristic A* brings together the best of both worlds. It makes use of multiple inadmissible but informative heuristics supported by an admissible heuristic, to find a suboptimal path as quickly as possible and continues to improve it until the expiration of the allocated time.

The rest of the paper is organized as follows: In the next section, we briefly go over the related work from anytime and multi-heuristic search. It will be followed by the proposed algorithm and the theoretical properties. We conclude with experimental results and future work.

Related Work

Efficiency of informed search algorithms, such as A* rely heavily on the accuracy of the heuristic functions. A* with an admissible heuristic is a provable optimal algorithm. However, its runtime and memory requirements often makes it unusable for large state spaces. Weighted A* (WA*) (?) can dramatically improve the runtime as it inflates the heuristic with a factor $w>1.0$, providing a greedy flavor to the search. It is also a bounded suboptimal algorithm, i.e., the solution obtained is bounded by $w$ times the optimal cost. With WA*, the reliance on the heuristic accuracy is magnified (compared to A*), and its performance can suffer significantly if the heuristic is subject to large local minima (?).

Multi Heuristic A* 111We refer to the Shared version of MHA* in the original paper as MHA* (?) alleviates this problem of careful heuristic construction by using multiple heuristics simultaneously to explore a search space. MHA* uses one consistent heuristic and multiple (possibly) inadmissible heuristics, to guide the search around local minima. It often performs better by exploiting the synergy provided by different heuristics, each of which maybe useful in different parts of the search space. MHA* provides guarantees on completeness and bounded suboptimality along with bounds on state expansion (at most 2 expansions per state). There are variants of the MHA* that improves upon the original by using intelligent scheduling or better bounding (?). MHA* and its variants have been recently applied to several complex search problems including fullbody planning (?).

A*, WA*, MHA* are all one shot algorithm, as such these do not provide a handle to reason about the trade-off between solution quality and runtime. Anytime search algorithms, on the other hand, iteratively improve the solution quality, and thus provide the user an opportunity to tradeoff runtime with solution quality. Anytime Repairing A* (ARA*) (?), is an anytime search algorithm that uses WA* for a particular iteration, and runs in an anytime mode by decreasing the suboptimality bound over time. ARA* has been successfully applied to many domains, such as autonomous cars, mobile manipulation, footstep planning, drones, etc. Other anytime search algorithms include, algorithms based on WA* (?) (?), beam search (?), sliding window search (?) etc.

Anytime Multi-Heuristic A* (A-MHA*)

**Notations: ** Let $s\in\mathcal{S}$ denote the finite set of discrete states over which we search for a path from $s_{start}$ to $s_{goal}$. The search typically proceeds by expanding states to generate successors $s^{\prime}\in Succ(s)$ based on a priority. The current best cost and the optimal cost to arrive at a state $s$ is denoted by $g(s)$ and $g^{*}(s)$. $c(s,s^{\prime})$ denotes the cost between any two states $s$ and $s^{\prime}$ connected by an edge.

As mentioned before, MHA* incorporates a single admissible heuristic $h_{0}(s)$ and multiple inadmissible heuristics denoted by $h_{i}(s),\ i=1,...,N$. In this paper, we refer to this admissible search as the anchor search and the other searches as inadmissible searches. We assume that we have access to such admissible and inadmissible heuristics. Let the inflation of the anchor search be $w_{1}$ and let $w_{2}$ be the inflation factor to prioritize inadmissible search. Because of the anytime nature of the algorithm, the inflation factors are updated and the found solution is improved over time. They are initialized to $w_{1}^{0}$ and $w_{2}^{0}$ and updated using $\Delta w_{1}$ and $\Delta w_{2}$. With one admissible heuristic and $N$ inadmissible heuristics, the $N+1$ priority queues of expansion are given by $OPEN_{0}$ and $OPEN_{i},\ i=1,...,N$ respectively. The priority of the states in $OPEN_{i}$ and $OPEN_{0}$ are given by $key(s,i)=g(s)+w_{1}*h_{i}(s)$. In order to track and prevent re-expansions within a single search improvement routine, we have anchor and inadmissible closed lists and an inconsistent list denoted as $CLOSED_{anch}$, $CLOSED_{inad}$, and $INCONS$ respectively.

Algorithm

The psuedocode of the proposed algorithm is presented in Algorithm 1. The structure of the A-MHA* is similar to anytime search algorithms like ARA* (?) or ANA* (?). The Main() function consists of the outer loop from which the ImprovePath() function is called with the updated suboptimality bound. The ImprovePath() function is a modified MHA* routine that guarantees $w_{1}*w_{2}$ suboptimality and keeps track of inconsistent states to reuse the search results during the next iteration. It consists of two parts, the one that exploits the $w_{1}$ bounded anchor search (Lines 23-24) and the other that explores the $w_{1}*w_{2}$ bounded paths through inadmissible search (Lines 20-21).

During every iteration of the ImprovePath() function, the option of expanding a state from $OPEN_{0}$ or $OPEN_{i}$ is decided depending on their minimum key and $w_{2}$ (Line 19). We build on the notion of local inconsistency from ARA* (?) to introduce the inconsistent list in A-MHA* and keep track of the states which were already expanded and whose $g(s)$ is reduced. During the Expand() operation, the state $s$ being expanded is popped from all the $N+1$ queues and checked if it could be a better predecessor (lower $g(s)+c(s,s^{\prime})$) to any of the successors $s^{\prime}$. An update of $g(s^{\prime})$ with a better predecessor could cause a local inconsistency between the g-value of $s^{\prime}$ and all its successors which has to be propagated by putting $s^{\prime}$ into $OPEN_{0}$ and $OPEN_{i}$. In case $s^{\prime}$ is already expanded (i.e. $s^{\prime}\in CLOSED_{anch}$ or $CLOSED_{inad}$), we delay this propagation by maintaining an $INCONS$ list, an idea developed in ARA* (Lines 8-12). We note that only one $INCONS$ list is needed despite having two $CLOSED$ lists. This can be understood from the observation that all the states added to any $OPEN_{i}$ are also added to $OPEN_{0}$ and when a state is expanded from $OPEN_{0}$, it is never re-expanded from any other $OPEN_{i}$ in the same ImprovePath() iteration. So if we find a better predecessor to a state which has not been expanded by $OPEN_{0}$ yet, the priority of the state is updated in $OPEN_{0}$ and if it has been expanded, it is added to the $INCONS$ list. Thus, after exiting ImprovePath(), the states from both $OPEN_{0}$ and $INCONS$ are added to both $OPEN_{0}$ and $OPEN_{i}$, thereby making sure that all the inconsistent states are tracked by just using $OPEN_{0}$ and a single $INCONS$ list.

After exiting from the ImprovePath(), the solution obtained is guaranteed to be $w_{1}*w_{2}$ suboptimal (proof in next subsection). Before the next call to ImprovePath(), we move the $INCONS$ states to $OPEN_{0}$ and $OPEN_{i}$, re-heap the queues, clear the $CLOSED_{anch}$ & $CLOSED_{inad}$ and update the $w_{1}$ and $w_{2}$ with $\Delta w_{1}$ and $\Delta w_{2}$ (Lines 31-40).

Properties of A-MHA*

In this subsection, we provide two important properties of A-MHA*. First, we show that the solution provided by any ImprovePath() call is $w_{1}*w_{2}$ suboptimal. Next, we show that within each call of ImprovePath(), a state is expanded at-most twice.

Theorem 1**.**

At the exit of ImprovePath(), the cost of the greedy path from $s_{start}$ to any state $s$, $g(s)$, is upper-bounded by $w_{1}*w_{2}$ times the cost of the optimal path to the goal $g^{*}(s_{goal})$.

Proof.

From WA* we know that any state $s$ expanded by the anchor search has a priority (and thereby $g(s)$) lesser than $w_{1}$ times the optimal path cost $g^{*}(s_{goal})$ (since the admissible heuristic is an underestimate of the actual cost). By imposing the condition specified in line 19, we restrict the inadmissible expansions only to states whose priority is lesser than $w_{1}*w_{2}$ times the optimal cost. Thus, for any state $s\in OPEN_{i}$ (whose heuristic could be an overestimate) to have a priority lesser than $w_{1}*w_{2}$ times the optimal cost, would imply that the current cost to reach that particular state $g(s)$ is lesser than $w_{1}*w_{2}$ times optimal path cost. Thus any expansion in the inadmissible search is bounded by $w_{1}*w_{2}$ times optimal path cost, including the expansion of the $s_{goal}$. Hence, the path found by ImprovePath() is guaranteed to be $w1*w2$ suboptimal.

∎

Theorem 2**.**

Within a single ImprovePath() call, any state is expanded atmost twice.

Proof.

If a state is expanded by a call to Expand(s) from anchor search in line 24, it is added to $CLOSED_{anch}$ and can never be expanded by both inadmissible and anchor search again (note the nested if condition between lines 8 and 15). Next, if a state is expanded by a call to Expand(s) from inadmissible search in line 21, it is added to $CLOSED_{inad}$ and can only be expanded by the anchor search (lines 12-15). Hence, in a single call to ImprovePath(), a state can only be expanded atmost twice. ∎

Experimental Results

We evaluate the performance of A-MHA* on the sliding tiles puzzle and 3D navigation (x,y,orientation) domains and compare it with the performance of other state of the art search algorithms. The experiments are setup similar to those in the original MHA* paper (?), to accurately evaluate the performance of our algorithm and compare in a fair manner.

3D Path Planning

Here, we plan for a polygonal robot with three degrees of freedom (x,y,orientation) in a 2-D planar environment. The plan has to satisfy the minimum turning radius constraints of the robot, which is imposed using motion primitives for generating successors from a state (similar to the lattice type planner (?)).

The consistent heuristic, which is the same across all the different planners, is the euclidean distance from the goal. In addition to this, the inadmissible heuristics used for MHA* and A-MHA* include an 8-connected Dijkstra search assuming the robot to have zero size and two other progressive heuristics obtained by running 8-connected Dijkstra search on a map created by blocking the narrow passages (passage width $\leq$ robot size) present in the current map.

From Figure 1 and 2, it is clear that A-MHA* is capable of producing a high quality solution much quicker than the other algorithms, which it continues to improve over time. However, it has to be noted that the usage of inadmissible heuristics delays the convergence to optimal solution.

Sliding Tiles Puzzle

In this subsection, we present the results for 48 and 63 sliding tiles puzzle, a domain commonly used to evaluate search algorithms. The consistent heuristic for this domain which is widely used in this literature is the sum of the Manhattan Distance ($MD$) and the Linear Conflict ($LC$). Similar to the original MHA* paper, the inconsistent heuristics are a weighted sum of the number of misplaced tiles ($MT$), $MD$ and $LC$, where the weights are randomly generated during execution.

From Table. 1 and 2, we understand that A-MHA* has the highest success rate (number of instances for which the puzzle was solved within a limited time) and clearly outperforms the other algorithms consistently. For 63 tile sliding puzzles, similar to the previous domain, A-MHA* produces high quality solutions in much lesser time, while converging to the final suboptimality bound slower. However, for the 48 tiles sliding puzzle environment, the performance of A-MHA* is comparable to that of ARA*. This is because the effect of the additional heuristics in a smaller environment might not have the same impact as it did in a bigger/complex environment and hence might not outweigh the overhead in maintaining several heaps.

Conclusion

We presented an anytime version of MHA*, while preserving completeness, expansion and suboptimality guarantees. Experimental results in two different domains strongly favor A-MHA* over the other anytime algorithms. This simple algorithm brings together the benefits of both ARA* and MHA*, thereby maximizing the performance in terms of both solution quality and run-time. One interesting future work could be nonparametrize the inflation factors of A-MHA* to circumvent the tedious process of tuning them.