1 / 37

Pathfinding

Pathfinding. COMP 4230, Spring 2013. Why search?. Consider this problem – given a set of integers, we want to output them in sorted order, smallest number first Say we want to sort {5, 2, 27 12} – the answer is {2, 5, 12, 27} First of all, do we have a quick way of checking an answer? Yes.

zion
Download Presentation

Pathfinding

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Pathfinding COMP 4230, Spring 2013

  2. Why search? • Consider this problem – given a set of integers, we want to output them in sorted order, smallest number first • Say we want to sort {5, 2, 27 12} – the answer is {2, 5, 12, 27} • First of all, do we have a quick way of checking an answer? Yes. currentNumber := first element of SA (SA is a list containing the answer) while (not at the end of SA) do nextNumber := the next element in SA if (currentNumber > nextNumber) signal no elsecurrentNumber := nextNumber signal yes

  3. So here’s a way to sort 5 2 5 S 2 2 2 5 5 27 12 27 12 27 12 27 12 12 12 27 27 12 27 27 … … 12 27 2 12 2 27 12 27 5 12 5 Is this a good way to sort numbers?

  4. Intriguing facts about computation • There exist problems which can be solved in a relatively small number of computations, in fact a polynomial number (P), like sort • There exist (many many interesting) problems which can not be solved in a polynomial number of computations – these are non-deterministic polynomial complete (NP-complete) problems • The NP-complete problems are the ones that can only be solved by search

  5. Warning! Beware! Search algorithms have the ability to create in the average human brain terrible amounts of frustration and confusion, leading to headaches, nausea, and sleep deprivation. Spontaneous and excessive howling is not uncommon. Please be aware these symptoms are commonplace in the early stages of the learning curve and are not generally cause for concern. Normal service is usually resumed within a reasonable length of time. (If symptoms persist, however, stay clear of busy roads, razor blades, and loaded weapons. See medical advice at the earliest opportunity.)

  6. Formalizing search • A search problem has five components: Q , S,G, succs, cost • Q is a finite set of states. • S ⊆ Q is a non-empty set of start states. • G ⊆ Q is a non-empty set of goal states. • succs : Q  P(Q) is a function which takes a state as input and returns a set of states as output. succs(s) means “the set of states you can reach from s in one step”. • cost : Q , Q  Positive Number is a function which takes two states, s and s’, as input. It returns the one-step cost of traveling from s to s’. The cost function is only defined when s’ is a successor state of s.

  7. Representing the search space • Search space represented as a graph of state transitions • Two typical representations • A graph of states, where arrows represent succ and nodes represent states – a state appears only once in the graph • A tree of states, where a path in the tree represents a sequence of search decisions – the same state can appear many times in the tree {5, 2, 12, 27} {5, 2, 12} {5, 2} {5} {5, 2, 27, 12} {5, 2, 27} Here’s our sort problem written out as a search graph {5, 12} {5, 12, 2, 27} {5, 27} {5, 12, 2} {2} … {5, 12, 27, 2} {} {5, 12, 27} {2, 5} … … {5, 27, 2, 12} {12} {5, 27, 2} {2, 12} … {5, 27, 12, 2} {5, 27, 12} … {2, 27} {27}

  8. An abstract search problem G S d p b a e h q c r f • Q = {START, a , b , c , d , e , f , h , p , q , r , GOAL} • S = { S } • G = { G } • succs(b) = { a } • succs(e) = { h , r } • succs(a) = NULL … etc. • cost(s,s’) = 1 for all transitions

  9. Some example search problems

  10. Aside: Why do we have to search? • “We may regard the present state of the universe as the effect of its past and the cause of its future. An intellect which at any given moment knew all of the forces that animate nature and the mutual positions of the beings that compose it, if this intellect were vast enough to submit the data to analysis, could condense into a single formula the movement of the greatest bodies of the universe and that of the lightest atom; for such an intellect nothing could be uncertain and the future just like the past would be present before its eyes.” -Marquis Pierre Simon de Laplace

  11. Breadth-first search • Label all states that are reachable from S in 1 step but aren’t reachable in less than 1 step. • Then label all states that are reachable from S in 2 steps but aren’t reachable in less than 2 steps. • Then label all states that are reachable from S in 3 steps but aren’t reachable in less than 3 steps. • Etc… until Goal state reached. • Try this out for our abstract search problem (Demo)

  12. Depth-first search • An alternative to BFS. Always expand from the most recently-expanded node, if it has any untried successors. Else backup to the previous node on the current path. • We use a data structure we’ll call a Path to represent the path from the START to the current state. E.G. Path P = <START, d, e, r> • Along with each node on the path, we must remember which successors we still have available to expand.E.G. P = <START (expand=e,p) , d (expand = b,c) , e (expand = h), r (expand = f) >

  13. DFS Algorithm Let P = <START (expand = succs(START))> While (P not empty and top(P) not a goal) if expand of top(P) is empty then remove top(P) (“pop the stack”) else let s be a member of expand of top(P) remove s from expand of top(P) make a new item on the top of path P: s (expand = succs(s)) If P is empty then return FAILURE Else return the path consisting of states in P

  14. Hard-coded Behavior • Sphex (Digger) Wasp • https://www.youtube.com/watch?v=5t2p4ukzL74 • https://www.youtube.com/watch?v=EXLigFEri98

  15. Uniform cost (Dijkstra) search • A conceptually simple BFS approach when there are costs on transitions • It uses a priority queue • PQ = Set of states that have been expanded or are awaiting expansion • Priority of state s = g(s) = cost of getting to s using path implied by backpointers. • Main loop • Pop least cost state from PQ (the open list) • Add the successors • Stop when the goal is popped from the PQ (the open list)

  16. Example graph Cost: 1.3 D E F G B Cost: 1.3 Cost: 1.9 A Cost: 1.6 Cost: 1.4 C Cost: 3.3 Cost: 1.3 Searching for a path from A to G

  17. Uniform cost example Connection: I Cost: 1.3 Cost-so-far: 1.3 Connection: I B C D A Connection: II Cost: 1.6 cost-so-far: 0 connection: none Cost-so-far: 1.6 Connection: II Connection: III Cost: 3.3 Cost-so-far: 3.3 Connection: III Closed List: A Open List: B, C, D

  18. Uniform cost example Cost-so-far: 1.3 Connection: I Connection: IV Cost: 1.3 Cost-so-far: 2.6 Connection: IV D F E Connection: I Cost: 1.3 B Cost-so-far: 3.2 Connection: V Connection: V Cost: 1.9 A Connection: II Cost: 1.6 cost-so-far: 0 connection: none Cost-so-far: 1.6 Connection: II C Connection: III Cost: 3.3 Cost-so-far: 3.3 Connection: III Closed List: A,B Open List: C, D, E, F

  19. Uniform cost example Cost-so-far: 1.3 Connection: I Connection: IV Cost: 1.3 Cost-so-far: 2.6 Connection: IV D E F Connection: I Cost: 1.3 B Cost-so-far: 3.2 Connection: V Connection: V Cost: 1.9 A Connection: II Cost: 1.6 cost-so-far: 0 connection: none Cost-so-far: 1.6 Connection: II C Connection: III Cost: 3.3 Connection: VI Cost: 1.3 Cost-so-far: 2.9 Connection: VI Closed List: A, B, C Open List: D, E, F

  20. Uniform cost example Cost-so-far: 1.3 Connection: I Connection: IV Cost: 1.3 Cost-so-far: 2.6 Connection: IV E D F Connection: I Cost: 1.3 B Cost-so-far: 3.2 Connection: V Connection: V Cost: 1.9 A Connection: II Cost: 1.6 cost-so-far: 0 connection: none Cost-so-far: 1.6 Connection: II C Connection: III Cost: 3.3 Connection: VI Cost: 1.3 Cost-so-far: 2.9 Connection: VI Closed List: A, B, C, E Open List: D, F

  21. Uniform cost example Cost-so-far: 1.3 Connection: I Connection: IV Cost: 1.3 Cost-so-far: 2.6 Connection: IV E F Connection: I Cost: 1.3 B Cost-so-far: 3.2 Connection: V Connection: V Cost: 1.9 A Connection: II Cost: 1.6 cost-so-far: 0 connection: none Cost-so-far: 1.6 Connection: II C Connection: III Cost: 3.3 Connection: VI Cost: 1.3 D Cost-so-far: 2.9 Connection: VI Closed List: A, B, C, E, D Open List: F

  22. Uniform cost example Cost-so-far: 1.3 Connection: I Connection: IV Cost: 1.3 Cost-so-far: 2.6 Connection: IV E Connection: I Cost: 1.3 B Cost-so-far: 3.2 Connection: V F Connection: V Cost: 1.9 A Connection: II Cost: 1.6 cost-so-far: 0 connection: none Connection: VII Cost: 1.4 Cost-so-far: 1.6 Connection: II C Connection: III Cost: 3.3 Cost-so-far: 4.6 Connection: VII G Connection: VI Cost: 1.3 D Cost-so-far: 2.9 Connection: VI Closed List: A, B, C, E, D Open List: Connections from G: VII, V, I Path: I, V, VII

  23. Data structure for the open list • We need a data structure for the open list that makes the following operations inexpensive: • Adding an entry to the list • Removing an entry from the list • Finding the smallest element • Finding an entry corresponding to a particular node • Let’s analyze how well a linked list works

  24. Priority heap 2 3 6 7 10 4 9 5 8 6 7 2 3 8 4 5 10 9 http://nova.umuc.edu/~jarc/idsv/lesson2.html

  25. Heuristic search • Suppose in addition to the standard search specification we also have a heuristic. • A heuristic function maps a state onto an estimate of the cost to the goal from that state. • What’s an example heuristic for path planning? • Denote the heuristic by a function h(s) from states to a cost value.

  26. Best first “greedy” search insert-PriQueue(PQ,START,h(START)) while (PQ is not empty and PQ does not contain a goal state) (s , h ) := pop-least(PQ) foreach s’ in succs(s) if s’ is not already in PQ and s’ never previously been visited insert-PriQueue(PQ, s’,h(s’)) • Greedy ignores the actual costs • An improvement to this algorithm becomes A*!

  27. A* search • Uniform-cost (Dijkstra): on expanding n, take each successor n’ and place it on priority queue with priority g(n’) (cost of getting to n’) • Best-first greedy: on expanding n, take each successor n’ and place it on priority queue with priority h(n’) • A*: When you expand n, place each successor n’ on priority queue with priority f(n’) = g(n’) + h(n’)

  28. When should A* terminate? h = 8 S h = 3 1 1 B A h = 7 1 7 h = 2 h = 0 1 C 7 D G h = 1 Should it terminate as soon as we generate the goal state?

  29. Correct A* termination rule h = 8 S h = 3 1 1 B A h = 7 1 7 h = 2 h = 0 1 C 7 D G h = 1 A* terminates when a goal state is popped from the priority queue (open list)

  30. A* revisiting states h = 8 S h = 3 1 1 B A h = 7 0.5 1 h = 2 h = 0 1 C 7 D G h = 1 What if A* revisits a state that was already expanded and discovers a shorter path? In this example, a state that was expanded gets re-expanded.

  31. A* revisiting states h = 8 S h = 3 1 1 B A h = 7 0.5 1 h = 8 h = 0 1 C 7 D G h = 1 What if A* visits a state that was already on the queue? In this example, a state on the queue and waiting for expansion has it’s priority changed.

  32. A* algorithm • Priority queues Open and Closed begin empty. Both queues contain records of the form (state, f, g, backpointer). • Put S into Open with priority f(s) = g(s) + h(s) = h(s) • Is Open empty? • Yes? No solution. • No. Remove node with lowest f(n). Call it n. • If n is a goal, stop and report success (for pathfinding, return the path) • Otherwise , expand n. For each n’ in successors(n) • Let f’ = g(n’) + h(n’) = g(n) + cost (n, n’) + h(n’) • If n’ not seen before or n’ previously expanded with f(n’) > f’ or n’ currently in Open with f(n’) > f’ • Then place or promote n’ on Open with priority f’ • Else ignore n’ • Place record for n in Closed

  33. Is A* guaranteed to find the optimal path? • Nope. Not if the heuristic overestimates the cost. h = 7 S h = 0 h = 6 1 3 G A 1

  34. Admissible heuristics • h*(n) = the true minimal cost to goal from n • A heuristic is admissible if h(n) <= h*(n) for all states n • An admissible heuristic is guaranteed to never overestimate the cost to the goal • An admissible heuristic is optimistic • What’s a common admissible heuristic for pathplanning?

  35. Euclidian distance • Guaranteed to be underestimating • Can provide fast pathplanning on outdoor levels with few constraints • May create too much fill on complex indoor levels 1 1 1 1 1.4 2.2 1 1

  36. Cluster heuristic Cluster B • Can be good for indoor levels • Pre-compute accurate heuristic between clusters • Use pre-computed values for points in two clusters, Euclidean (or something else simple) within clusters Cluster A C A B A B C Cluster C

  37. Ms. Pac-Man • Game.java • Game.getShortestPath() • Game.getShortestPathDistance() • PathsCache.java • getPathFromA2B() • getPathDistanceFromA2B()

More Related