# Welcome back

## Find a book, put up your feet, stay awhile

Sign in with Facebook

Sorry, we are unable to log you in via Facebook at this time. Please try again later.

or

Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more

Download

Standard view

Full view

of .

Look up keyword

Like this

Share on social networks

8Activity

×

0 of .

Results for: No results containing your search query

P. 1

Breadth First Heuristic SearchRatings: (0)|Views: 235|Likes: 11

Published by newtonapple

See more

See less

https://www.scribd.com/doc/28194917/Breadth-First-Heuristic-Search

09/04/2012

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-ﬁrst 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-ﬁrst instead of a best-ﬁrst search strategy.We describe optimal and approximate breadth-ﬁrst 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 Artiﬁcial 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 ﬁnding 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 identiﬁed.The contribution of this paper is to show that when usingdivide-and-conquer solution reconstruction, a breadth-ﬁrstsearch strategy is more memory-efﬁcient than a best-ﬁrststrategy. Although breadth-ﬁrst 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-ﬁrst 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 ﬁnding an opti-mal path from the start node to the midpoint node, and theproblem of ﬁnding an optimal path from the midpoint nodeto the goal node. Each of these subproblems is solved bythe original search algorithm, in order to ﬁnd 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 identiﬁed.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 sufﬁcient 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 inﬁnite

f

-costto prevent them from being expanded until a legal path isfound. Note that these

virtual nodes

acquire an actual, ﬁnitecost 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-ﬁrst 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-ﬁrst order. However, layersare deﬁned 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-ﬁrst 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-ﬁrstsearch algorithm to guarantee that when a node is ﬁrst 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 modiﬁcationsof the algorithm, and we postpone discussion of it to a laterpaper.A breadth-ﬁrst 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-ﬁrst 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

f

(

g

) =

g

(

n

) +

h

(

n

)

,where

h

is an admissible heuristic. No node is inserted intothe Open list if its

f

-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-ﬁrst 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-ﬁrst branch-and-bound search. If all expanded nodesare stored in memory, breadth-ﬁrst branch-and-bound usesas much or more memory than A*, and has no advantage.But we propose a breadth-ﬁrst 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-ﬁrst branch-and-bound search algorithm can be much morememory-efﬁcient than a best-ﬁrst algorithm such as DCFA*or Sparse-memory A*.Figure 2 conveys an intuition of how breadth-ﬁrst searchresults in a smaller set of boundary nodes. It shows that best-ﬁrst node expansion ”stretches out” the boundary, whereasbreadth-ﬁrst search does not and uses the upper bound tolimit the width of the boundary. Although breadth-ﬁrstsearch expands more nodes than best-ﬁrst search, the mem-ory it saves by storing a smaller boundary results in moreefﬁcient search, as our test results will show.Before discussing details of the algorithm, we considerthe question: how many layers of the breadth-ﬁrst searchgraph need to be stored in memory to prevent duplicatesearch effort?Figure 2:

Comparison of best-ﬁrst and breadth-ﬁrst boundaries.The outer ellipse encloses all nodes with

f

-cost less than or equalto an (optimal) upper bound.

Duplicate elimination

When nodes are expanded in breadth-ﬁrst 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.

Deﬁnition 1

The

locality

of a breadth-ﬁrst search graph isdeﬁned as

max

n,n

∈

N s.t. n

∈

pred

(

n

)

{

g

∗

(

n

)

−

g

∗

(

n

)

,

0

}

,

where

N

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

ﬁrst 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-ﬁrst 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

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

- Read and print without ads
- Download to keep your version
- Edit, email or read offline

© Copyright 2015 Scribd Inc.

Language

Choose the language in which you want to experience Scribd:

Sign in with Facebook

Sorry, we are unable to log you in via Facebook at this time. Please try again later.

or

Password Reset Email Sent

Join with Facebook

Sorry, we are unable to log you in via Facebook at this time. Please try again later.

or

By joining, you agree to our

read free for one week

Personalized recommendationsbased on books you love

Syncing across all your devices

Join with Facebook

or Join with EmailSorry, we are unable to log you in via Facebook at this time. Please try again later.

Already a member? Sign in.

By joining, you agree to our

to download

Personalized recommendationsbased on books you love

Syncing across all your devices

Continue with Facebook

Sign inJoin with emailSorry, we are unable to log you in via Facebook at this time. Please try again later.

By joining, you agree to our

Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

CANCEL

OK

You've been reading!

NO, THANKS

OK

scribd