Welcome to Scribd. Sign in or start your free trial to enjoy unlimited e-books, audiobooks & documents.Find out more
Download
Standard view
Full view
of .
Look up keyword
Like this
8Activity
0 of .
Results for:
No results containing your search query
P. 1
Breadth First Heuristic Search

Breadth First Heuristic Search

Ratings: (0)|Views: 235|Likes:
Published by newtonapple

More info:

Published by: newtonapple on Mar 11, 2010
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

09/04/2012

pdf

text

original

 
14th International Conference on Automated Planning and Scheduling (ICAPS-04)Whistler, British Columbia, Canada
June 3 - 7, 2004
Breadth-First Heuristic Search
Rong Zhou and Eric A. Hansen
Department of Computer Science and EngineeringMississippi State University, Mississippi State, MS 39762
{
rzhou,hansen
}
@cse.msstate.edu
Abstract
Recent work shows that the memory requirements of best-first heuristic search can be reduced substantially by using adivide-and-conquer method of solution reconstruction. Weshow that memory requirements can be reduced even furtherby using a breadth-first instead of a best-first search strategy.We describe optimal and approximate breadth-first heuristicsearch algorithms that use divide-and-conquer solution re-construction. Computational results show that they outper-form other optimal and approximate heuristic search algo-rithms in solving domain-independent planning problems.
Introduction
The A* graph-search algorithm and its variants are widelyused for path planning, robot motion planning, and domain-independent STRIPS planning. But as is well-known, thescalability of A* is limited by its memory requirements. A*stores all explored nodes of a search graph in memory, us-ing an Open list to store nodes on the search frontier and aClosed list to store already-expanded nodes. This serves twopurposes. First, it allows the optimal solution path to be re-constructed after completion of the search by tracing point-ers backwards from the goal node to the start node. Second,it allows nodes that have been reached along one path to berecognized if they are reached along another path, in orderto prevent duplicate search effort. It is necessary to store allexplored nodes in order to perform both functions, but notto perform just one. This leads to two different strategies forreducing the memory requirements of heuristic search: onestrategy gives up duplicate elimination and the other givesup the traceback method of solution reconstruction.Linear-spacevariantsofA*suchasIDA*(Korf1985)andRBFS (Korf 1993) give up duplicate elimination. Instead of storing Open and Closed lists, they use a stack to organizethe search. Since the current best solution path is stored onthe stack, solution reconstruction by the traceback methodis straightforward. But because they only store nodes on thecurrent path, they are severely limited in their ability to rec-ognize when newly-generated nodes have been previouslyexplored. Essentially, linear-space search algorithms con-vert graph-search problems into tree-search problems. This
Copyrightc
2004, American Association for Artificial Intelli-gence (www.aaai.org). All rights reserved.
can lead to an exponential increase in the time complexity of search (measured by the number of node expansions) as thedepth of the search increases, and for complex graph-searchproblems with many duplicate paths, IDA* and RBFS canperform very poorly, due to excessive node re-generations.Theirperformancecanbeimprovedbyusingavailablemem-ory to store as many explored nodes as possible in or-der to check for duplicates (Reinefeld & Marsland 1994;Miura & Ishida 1998), but this requires as much memoryas A* to eliminate
all
duplicate search effort.A second strategy for reducing the memory requirementsof search prevents duplicate search effort, but does not usethe traceback method of solution reconstruction. It is basedon the insight that it is not necessary to store all expandednodes in order to prevent node re-generation. It is only nec-essary to store enough to form a
boundary
between the fron-tier and interior of the search graph. This strategy was in-troduced to the AI community in a pair of related search al-gorithms (Korf 1999; Korf & Zhang 2000), which in turnare related to earlier work on reducing the memory re-quirements of dynamic programming for sequence compar-ison (Hirschberg 1975). Instead of the traceback method,this strategy uses a divide-and-conquer method of solutionreconstruction in which memory is saved by finding a nodein the middle of an optimal path, instead of the complete op-timal path, and then using the midpoint node to divide theoriginal problem into two sub-problems. Each subproblemis solved recursively by the same algorithm until all nodeson the optimal path are identified.The contribution of this paper is to show that when usingdivide-and-conquer solution reconstruction, a breadth-firstsearch strategy is more memory-efficient than a best-firststrategy. Although breadth-first search may lead to morenode expansions, it reduces the size of the set of boundarynodes that need to be retained in memory. This allows largerproblems to be solved. To substantiate this claim, our pa-per begins with a review of best-first search algorithms thatusedivide-and-conquersolutionreconstruction. Thenwein-troduce a family of breadth-heuristic search algorithms thatincludes Breadth-First Iterative-Deepening A* for optimalsearch, and Divide-and-Conquer Beam Search for approx-imate search. Computational results for the Fifteen Puzzleand for domain-independent STRIPS planning show the ad-vantages of this approach.
 
Divide-and-conquer solution reconstruction
The divide-and-conquer strategy for solution reconstructionhas long been used to reduce the space complexity of dy-namic programming for sequence comparison (Hirschberg1975; Myers & Miller 1988). It was recently introduced tothe heuristic search community by Korf (1999). Korf andZhang (2000) describe a version of A* that uses it. Zhouand Hansen (2003a; 2003b) introduce enhancements.The strategy is based on recognition that it is not neces-sary to store all expanded nodes in a Closed list in order toprevent re-generation of already-expanded nodes. It is onlynecessary to store a subset of nodes that forms a
boundary
between the frontier and interior of the search graph. Theconcept of a “boundary” expresses the intuition that the setof explored nodes forms a “volume” that encompasses thestart node and grows outward, and no unexpanded node out-side the boundary can reach an already-expanded node with-out passing through some node in the boundary, as illus-trated by Figure 1. Thus, storing only the boundary nodesis as effective as storing all expanded nodes with respect topreventing node re-generation.Although nodes inside the boundary can be removed frommemory without risking duplicate search effort, this meansit is no longer possible to reconstruct a solution by the tra-ditional traceback method. To allow divide-and-conquer so-lution reconstruction, each node stores information about anode along an optimal path to it that divides the problem inabout half. Once the search problem is solved, informationabout this midpoint node is used to divide the search prob-lem into two sub-problems: the problem of finding an opti-mal path from the start node to the midpoint node, and theproblem of finding an optimal path from the midpoint nodeto the goal node. Each of these subproblems is solved bythe original search algorithm, in order to find a node in themiddle of their optimal paths. The process continues recur-sively until primitive subproblems (in which the goal nodeis an immediate successor of the start node) are reached, andall nodes on the optimal solution path have been identified.Since the time it takes to solve all subproblems is very shortcompared to the time it takes to solve the original searchproblem, this approach saves a great deal of memory in ex-changeforlimitedtimeoverheadforsolutionreconstruction.Search algorithms that use this strategy to reduce memoryrequirements differ in detail. In Korf and Zhang’s (2000)Divide-and-Conquer Frontier Search (DCFA*), each nodepast the midpoint of the search stores (via propagation) allstate information about a node along an optimal path to thisnode that is about halfway between the start and goal node.In Sparse-Memory A* (Zhou & Hansen 2003a), each nodestores a pointer to its predecessor or to an intermediate nodealong an optimal path, called a
relay node
, that is retained inmemory. Since storing pointers and relay nodes takes lessspace and allows faster solution reconstruction, we adoptthat technique in this paper.Algorithms also differ in how they distinguish the bound-ary from closed nodes that can be removed from memory.For example, DCFA* only stores the frontier nodes of thesearch (the Open List) and not the interior nodes (the Closedlist). Already-closed nodes are prevented from being re-Figure 1:
A set of boundary nodes separates the frontier from theinterior of the search graph. (All nodes inside the boundary areclosed and all nodes outside the boundary are open. The boundaryitself may contain closed and/or open nodes.)
generated by storing a list of 
forbidden operators
in eachnode. The list includes one operator (stored as a bit) foreach potential successor of the node that has already beengenerated. Each time a node is expanded, each of its suc-cessor nodes is given a forbidden operator that blocks re-generation of the just-expanded node. In undirected graphs,this is sufficient to prevent re-generation of already-closednodes. In directed graphs in which a node can have prede-cessors that are not also potential successors, an additionaltechnique must be used. Each time a node is expanded, allof its predecessor nodes are generated as well as its succes-sor nodes. If the search has not yet found a legal path tothese predecessor nodes, they are assigned an infinite
-costto prevent them from being expanded until a legal path isfound. Note that these
virtual nodes
acquire an actual, finitecost once a path to them is found.Zhou and Hansen (2003a) propose a different techniquefor preventing node re-generation that does not require for-bidden operators or virtual nodes. Instead, they associatewith each node a counter that is initially set to the num-ber of potential predecessors of a node. Each time a nodeis expanded, the counter of each of its successors is decre-mented. Closed nodes can be removed from memory whentheir counter is equal to zero.For the special case of multiple sequence alignment, Zhouand Hansen (2003b) propose an even simpler technique. Be-cause the search graph of the multiple sequence alignmentproblem is a lattice, it can be decomposed into a sequenceof layers such that each node in a layer can only have suc-cessors in the current layer or the next layer, but not in anyprevious layer. If all nodes in one layer are expanded beforethe next layer is considered, then all previously-expandedlayers can be removed from memory without risking nodere-generation. Because this technique does not require for-bidden operators, virtual nodes or predecessor counters, it ismuch easier to implement. It also uses much less memorythan DCFA* or Sparse-Memory A*.The breadth-first heuristic search algorithms we introducein this paper can be viewed as generalizations of this algo-rithm, in that they also expand the search graph on a layer-by-layer basis instead of in best-first order. However, layersare defined differently, and the algorithms we introduce aremore general in the sense that they can search graphs witharbitrary structure, and not simply graphs that share the lat-tice structure of the multiple sequence alignment problem.
 
Breadth-First Heuristic Search
In the rest of this paper, we describe a family of heuristicsearch algorithms that use divide-and-conquer solution re-construction in combination with a breadth-first strategy of node expansion. The only assumption we make about thegraphs searched by these algorithms is that all edges haveunitcost; inotherwords, weassumeplanningproblemshaveunit-cost actions. This assumption allows a breadth-firstsearch algorithm to guarantee that when a node is first gen-erated, an optimal path to it has been found. Our approachcan be extended to graphs that have varying and real-valuededge costs. But this extension requires some modificationsof the algorithm, and we postpone discussion of it to a laterpaper.A breadth-first search graph divides into layers, one foreach depth. Since actions have unit cost, all nodes in thesame layer have the same
g
-cost, which is identical to theirdepth in the graph. Although nodes are expanded in breadth-first order, we use a lower-bound heuristic function to limitexploration of the search space. As in A*, a lower-boundestimate of the cost of an optimal path through node
n
isgiven by a node evaluation function
(
g
) =
g
(
n
) +
h
(
n
)
,where
h
is an admissible heuristic. No node is inserted intothe Open list if its
-cost is greater than an upper boundon the cost of an optimal solution, since such nodes cannotbe on an optimal path. We discuss how to obtain an upperbound later in this section.So far, the algorithm we have described is essentiallybreadth-first branch-and-bound search. This search strat-egy is rarely used in practice because the number of nodesit expands is at least as great, and usually greater, than thenumber of nodes expanded by A*, which can be viewed asbest-first branch-and-bound search. If all expanded nodesare stored in memory, breadth-first branch-and-bound usesas much or more memory than A*, and has no advantage.But we propose a breadth-first branch-and-bound algo-rithm that uses divide-and-conquer solution reconstruction.Its memory requirements depend on the number of nodesneeded to maintain a boundary between the frontier and in-terior of the search, and not the total number of nodes ex-panded. The central result of our paper is that when divide-and-conquer solution reconstruction is used, a breadth-first branch-and-bound search algorithm can be much morememory-efficient than a best-first algorithm such as DCFA*or Sparse-memory A*.Figure 2 conveys an intuition of how breadth-first searchresults in a smaller set of boundary nodes. It shows that best-first node expansion ”stretches out” the boundary, whereasbreadth-first search does not and uses the upper bound tolimit the width of the boundary. Although breadth-firstsearch expands more nodes than best-first search, the mem-ory it saves by storing a smaller boundary results in moreefficient search, as our test results will show.Before discussing details of the algorithm, we considerthe question: how many layers of the breadth-first searchgraph need to be stored in memory to prevent duplicatesearch effort?Figure 2:
Comparison of best-first and breadth-first boundaries.The outer ellipse encloses all nodes with
-cost less than or equalto an (optimal) upper bound.
Duplicate elimination
When nodes are expanded in breadth-first order, the Openand Closed lists of the algorithm can be considered to havea layered structure, where
Open
denotes the set of opennodes in layer
and
Closed
denotes the set of closed nodesin layer
. As a result, we sometimes refer to the Open orClosed list of a particular layer, as if each layer has its ownOpen and Closed lists. Note that at any time, all open nodesare in the current layer or in the next layer, whereas closednodes can be in the current layer or any previous layer.Each time the algorithm expands a node in the currentlayer, it checks whether each successor node is a duplicateof a node that is in the Open list of the next layer, or whetherit is a duplicate of a node in the Open or Closed list of thecurrent layer. In addition, it checks whether it is a duplicateof a node that is in the Closed list of one or more previouslayers. This raises the following crucial question: how manyprevious layers must be retained in memory and checked forduplicates to prevent re-generation of already-closed nodes?The answer determines when a closed layer of the searchgraph can be removed from memory. As it turns out, theanswer depends on the structure of the graph.
Definition 1
The
locality
of a breadth-first search graph isdefined as
max
n,n
N s.t. n
 pred
(
n
)
{
g
(
n
)
g
(
n
)
,
0
}
,
where
is the set of nodes,
g
(
n
)
is the length of a shortest  path to node
n
(or equivalently, it is the layer in which node
n
first appears), and 
pred
(
n
)
is the set of predecessors of 
n
.
Note that
g
(
n
)
can never be less than
g
(
n
)
by more thanone. But in general, there is no a priori limit on how muchgreater
g
(
n
)
can be than
g
(
n
)
. In other words, the short-est path to a node
n
may be arbitrarily longer than the short-est path to its successor node
n
. The locality of a graph de-terminesthe“thickness”ofthesetofboundarynodesneededto completely prevent duplicate nodes.
Theorem 1
The number of previous layers of a breadth-first search graph that need to be retained to prevent duplicatesearch effort is equal to the locality of the search graph.Proof 
: First assume that the number of previous layers savedinmemoryislessthanthelocality
k
ofthegraph. Toseehowthis can result in re-generation of a node, consider nodes
n

Activity (8)

You've already reviewed this. Edit your review.
1 thousand reads
1 hundred reads
David Allan Lane liked this
kccasey liked this
Akash Duhoon liked this
11458 liked this
Arpan Bhardwaj liked this
najmizabidi liked this

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->