1
|
|
2
|
- Chapter 4 Section 1 - 3
- Excludes memory-bounded heuristic search
|
3
|
- Best-first search
- Greedy best-first search
- A* search
- Heuristics
- Local search algorithms
- Online search problems
|
4
|
- A search strategy is defined by picking the order of node expansion
|
5
|
- Idea: use an evaluation function f(n) for each node
- estimate of "desirability"
- Expand most desirable unexpanded node
- Implementation:
- Order the nodes in fringe in decreasing order of desirability
- Special cases:
- greedy best-first search
- A* search
|
6
|
|
7
|
- Evaluation function f(n) = h(n) (heuristic)
- = estimate of cost from n to goal
- e.g., hSLD(n) = straight-line distance from n to Bucharest
- Greedy best-first search expands the node that appears to be closest to
goal
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
- Complete? No – can get stuck in loops,
e.g., Iasi à Neamt
à Iasi à Neamt à …
- Time? O(bm), but a good heuristic can give
dramatic improvement
- Space? O(bm): keeps all nodes in memory
- Optimal? No
|
13
|
- Idea: avoid expanding paths that are already expensive
- Evaluation function f(n) = g(n) + h(n)
- g(n) = cost so far to reach n
- h(n) = estimated cost from n to goal
- f(n) = estimated total cost of path through n to goal
|
14
|
|
15
|
|
16
|
|
17
|
|
18
|
|
19
|
|
20
|
- A heuristic h(n) is admissible if for every node n,
- h(n) ≤ h*(n), where h*(n) is the true cost
to reach the goal state from n.
- An admissible heuristic never overestimates the cost to reach the goal,
i.e., it is optimistic
- Example: hSLD(n) (never overestimates the actual road
distance)
- Theorem: If h(n) is admissible, A* using TREE-SEARCH is
optimal
|
21
|
- Suppose some suboptimal goal G2 has been generated and is in
the fringe. Let n be an unexpanded node in the fringe such that n is on
a shortest path to an optimal goal G.
- f(G2) = g(G2) since
h(G2) = 0
- g(G2) > g(G) since G2 is suboptimal
- f(G) = g(G) since h(G) = 0
- f(G2) > f(G) from
above
|
22
|
- Suppose some suboptimal goal G2 has been generated and is in
the fringe. Let n be an unexpanded node in the fringe such that n is on
a shortest path to an optimal goal G.
- f(G2) > f(G) from above
- h(n) ≤ h^*(n) since h is admissible
- g(n) + h(n) ≤ g(n) + h*(n)
- f(n) ≤ f(G)
- Hence f(G2) > f(n), and A* will never select G2
for expansion
|
23
|
- A heuristic is consistent if for every node n, every successor n' of n
generated by any action a,
- h(n) ≤ c(n,a,n') + h(n')
- If h is consistent, we have
- f(n') = g(n') + h(n')
- = g(n) + c(n,a,n') + h(n')
- ≥ g(n) + h(n)
- = f(n)
- i.e., f(n) is non-decreasing along any path.
- Theorem: If h(n) is consistent, A* using GRAPH-SEARCH is optimal
|
24
|
- A* expands nodes in order of increasing f value
- Gradually adds "f-contours" of nodes
- Contour i has all nodes with f=fi, where fi < fi+1
|
25
|
- Complete? Yes (unless there are infinitely many nodes with f ≤
f(G) )
- Time? Exponential
- Space? Keeps all nodes in memory
- Optimal? Yes
|
26
|
- E.g., for the 8-puzzle:
- h1(n) = number of misplaced tiles
- h2(n) = total Manhattan distance
- (i.e., no. of squares from desired location of each tile)
- h1(S) = ?
- h2(S) = ?
|
27
|
- E.g., for the 8-puzzle:
- h1(n) = number of misplaced tiles
- h2(n) = total Manhattan distance
- (i.e., no. of squares from desired location of each tile)
- h1(S) = ? 8
- h2(S) = ? 3+1+2+2+2+3+3+2 = 18
|
28
|
- If h2(n) ≥ h1(n) for all n (both admissible)
- then h2 dominates h1
- h2 is better for search
- Typical search costs (average number of nodes expanded):
- d=12 IDS = 3,644,035 nodes
A*(h1) = 227 nodes
A*(h2) = 73 nodes
- d=24 IDS = too many nodes
A*(h1) = 39,135 nodes
A*(h2) = 1,641 nodes
|
29
|
- A problem with fewer restrictions on the actions is called a relaxed
problem
- The cost of an optimal solution to a relaxed problem is an admissible
heuristic for the original problem
- If the rules of the 8-puzzle are relaxed so that a tile can move anywhere,
then h1(n) gives the shortest solution
- If the rules are relaxed so that a tile can move to any adjacent square,
then h2(n) gives the shortest solution
|
30
|
- In many optimization problems, the path to the goal is irrelevant; the
goal state itself is the solution
- State space = set of "complete" configurations
- Find configuration satisfying constraints, e.g., n-queens
- In such cases, we can use local search algorithms
- keep a single "current" state, try to improve it
|
31
|
- Put n queens on an n × n board with no two queens on the same row,
column, or diagonal
|
32
|
- "Like climbing Everest in thick fog with amnesia"
|
33
|
- Problem: depending on initial state, can get stuck in local maxima
|
34
|
- h = number of pairs of queens that are attacking each other, either
directly or indirectly
- h = 17 for the above state
|
35
|
|
36
|
- Idea: escape local maxima by allowing some "bad" moves but gradually
decrease their frequency
|
37
|
- One can prove: If T decreases slowly enough, then simulated annealing
search will find a global optimum with probability approaching 1
- Widely used in VLSI layout, airline scheduling, etc
|
38
|
- Why keep just one best state?
- Can be used with randomization too
|
39
|
- A successor state is generated by combining two parent states
- Start with k randomly generated states (population)
- A state is represented as a string over a finite alphabet (often a
string of 0s and 1s)
- Evaluation function (fitness function). Higher values for better states.
- Produce the next generation of states by selection, crossover, and
mutation
|
40
|
- Fitness function: number of non-attacking pairs of queens (min = 0, max
= 8 × 7/2 = 28)
- 24/(24+23+20+11) = 31%
- 23/(24+23+20+11) = 29% etc.
|
41
|
|
42
|
- Many problems are offline
- Do search for action and then perform action
- Online search interleave search & execution
- Necessary for exploration problems
- New observations only possible after acting
|
43
|
- Actual cost of path
- Best possible cost
- (if agent knew space in advance)
- 30/20 = 1.5
- For cost, lower is better
|
44
|
- Exploration problems: agent physically in some part of the state space.
- e.g. solving a maze using an agent with local wall sensors
- Sensible to expand states easily accessible to agent (i.e. local states)
- Local search algorithms apply (e.g.,
hill-climbing)
|
45
|
|
46
|
|
47
|
- Build a game player
- Restricted by time per move (specifics TBA)
- Interact with the game driver through command line
- Each turn, we will run your program, providing a a grid as input.
- Your output will be just the coordinates of your stone placement.
|
48
|
- Note: we haven’t yet covered all of the methods to solve this problem
- This week: start thinking about it, discuss among yourselves (remember
the G.I. Rule!)
- What heuristics are good to use?
- What type of search makes sense to use?
|