1. Artificial Intelligence Informed Search Algorithms
Dr. Shahriar Bijani
Shahed University
Spring 2017

2. Slides’ Reference
S. Russell and P. Norvig, Artificial Intelligence: A Modern Approach, Chapter 3, Prentice Hall, 2010, 3rd Edition.

3. Outline Best-first search Heuristics Local search algorithms
Greedy best-first search
A* search
Memory-Bounded Search
Heuristics
Local search algorithms
Hill-climbing search
Simulated annealing search
Local beam search
Genetic algorithms

4. Best-first search Idea: use an evaluation function f(n) for each node
Estimation of of "desirability"
Expand most desirable unexpanded node
Implementation:
Order the nodes in the fringe in decreasing order of desirability
Special cases:
Greedy best-first search
A* search

5. Romania with step costs in km

6. Greedy best-first search
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

7. Greedy best-first search example
straight line distance
h(n)
h(n) =234
406

8. Greedy best-first search example

9. Greedy best-first search example

10. Greedy best-first search example

11. Greedy best-first search example

12. Greedy best-first search example
Arad  Sibiu  Fagaras  Bucharest

13. Another example

14. Another example

15. Another example

16. Another example

17. Another example

18. Another example

19. Another example
Start  A  D  E  Goal

20. Greedy best-first infinite loopA
h(n)=10
h(n)=9 B
h(n)=7 C
infinite loop D
h(n)=3 E
h(n)=5 F
h(n)=0

21. Greedy best-first not optimal
h(n)=10
h(n)=9 B
h(n)=7
h(n)=5 C D E
h(n)=4
h(n)=2 G F
h(n)=3 H
h(n)=0

22. Greedy best-first not optimal
goal to reach the largest-sum 9 6 17 8 7 6 80

23. Greedy best-first not optimal
goal  to reach the largest value 9 6 17 8 7 6 80

24. Greedy best-first not optimal
goal  to reach the largest value 9 6 17 8 7 6 80

25. Properties of greedy best-first search
Complete?
No – can get stuck in loops, e.g., Tehran  Karaj  Tehran  Karaj 
Time?
O(bm): but a good heuristic can give dramatic improvement
Space?
O(bm): keeps all nodes in memory
Optimal? No

26. A* search
The most widely known form of best-first search is called A* search ("A-star search").
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 (i.e. cheapest solution) through n to goal

27. A* search example

28. A* search example

29. Comparing A* and greedy search
greedy search path  = 450
A* search path  = 418

30. A* search: another example
Assume h(n)=

31. A* search: another example
f(n) = g(n) + h(n)

33. Admissible heuristics
A heuristic h(n) is admissible if for every node n,
h(n)≤ h*(n), h*(n): 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

34. Optimality of A* (proof)
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

35. Optimality of A* (proof)
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)
 f(G2) > f(n), and A* will never select G2 for expansion

36. Consistent heuristics
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

37. Optimality of A* 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

38. Properties of A*
Complete? Yes (unless there are infinitely many nodes with f ≤ f(G) )
Time?
Exponential
Space?
Keeps all nodes in memory
Optimal?
Yes

39. About Heuristics
Heuristics are intended to orient the search along promising paths
The time spent computing heuristics must be recovered by a better search
A heuristic function could consist of solving the problem; then it would perfectly guide the search
Deciding which node to expand is sometimes called meta-reasoning
Heuristics may not always look like numbers and may involve large amount of knowledge

40. Heuristic Accuracy
h(N) = 0 for all nodes is admissible and consistent. Hence, breadth-first and uniform-cost are specific A* !
Let h1 and h2 be two admissible and consistent heuristics such that for all nodes N: h1(N)  h2(N). h2 is more informed (or more accurate) than h1.
h2 dominates h1
Claim 3: Every node expanded by A* using h2 is also expanded by A* using h1.

41. Heuristic Function
Function h(N) that estimates the cost of the cheapest path from node N to goal node.
Example: 8-puzzle 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
h(N) = number of misplaced tiles = 6
goal N

42. Heuristic Function
Function h(N) that estimates the cost of the cheapest path from node N to goal node.
Example: 8-puzzle 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
h(N) = sum of the distances of
every tile to its goal position =
= 13
goal N

43. Robot Navigation YN XN h(N) = Straight-line distance to the goal
= [(Xg – XN)2 + (Yg – YN)2]1/2

44. 8-Puzzle f(N) = h(N) = number of misplaced tiles 3 4 3 4 5 3 3 4 2 4 44 4 2 1

45. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles 3+3
3+4
1+5
1+3
2+3
2+4
5+2
5+0
0+4
3+4
3+2
4+1

46. 8-Puzzle
f(N) = h(N) =  distances of tiles to goal 6 4 5 3 2 5 4 2 1

47. Robot navigation Cost of one horizontal/vertical step = 1
Cost of one diagonal step = 2
h(N) = straight-line distance to the goal is admissible

48. Robot Navigation

49. Robot Navigation f(N) = h(N), with h(N) = Distance to the goal 2 1 5 82 1 5 8 7 3 4 6

50. Robot Navigation f(N) = h(N), with h(N) = Distance to the goal 8 7 6 54 3 2 3 4 5 6 7 5 4 3 5 6 3 2 1 1 2 4 7 7 6 5 8 7 6 5 4 3 2 3 4 5 6

51. Robot Navigation f(N) = g(N)+h(N), with h(N) = Distance to goal 7+2
8+3 2 1 5 8 7 3 4 6
8+3
7+4
7+4
6+5
5+6
6+3
4+7
5+6
3+8
4+7
3+8
2+9
2+9
3+10
7+2
6+1
2+9
3+8
6+1
8+1
7+0
2+9
1+10
1+10
0+11
7+0
7+2
6+1
8+1
7+2
6+3
6+3
5+4
5+4
4+5
4+5
3+6
3+6
2+7
2+7
3+8

52. Robot Navigation
f(N) = g(N) + h(N), with h(N) = straight-line distance from N to goal
Cost of one horizontal/vertical step = 1
Cost of one diagonal step = 2

53. 8-Puzzle 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 N
goal
h1(N) = number of misplaced tiles = 6
is admissible
h2(N) = sum of distances of each tile to goal = is admissible
h3(N) = (sum of distances of each tile to goal) x (sum of score functions for each tile) = is not admissible

54. Relaxed problems
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

55. ‘A’ Search Algorithm
If h(n) was not acceptable, then we have A search algorithm.
A is not optimal.

56. Memory Bounded Searches
IDA*
RBFS
SMA*

57. Iterative Deepening A* (IDA*)
Use f(N) = g(N) + h(N) with admissible and consistent h
Each iteration is depth-first with cutoff on the value of f of expanded nodes

58. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 6
Cutoff=4

59. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 6 4 6
Cutoff=4

60. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 6 4 5 6
Cutoff=4

61. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles5 4 6 4 5 6
Cutoff=4

62. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles6 5 4 6 4 5 6
Cutoff=4

63. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 6
Cutoff=5

64. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 6 4 6
Cutoff=5

65. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 6 4 5 6
Cutoff=5

66. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 6 4 5 6
Cutoff=5 7

67. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 5 4 6 5 6 7
Cutoff=5

68. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 5 5 6 4 5 6 7
Cutoff=5

69. 8-Puzzle f(N) = g(N) + h(N) with h(N) = number of misplaced tiles4 5 5 6 4 5 6 7
Cutoff=5

70. IDA* properties
With the same conditions for A*, it is complete & optimal.
Saving space, because of depth-first search.
Space longest path
Does not save the history  repeated states

71. RBFS RBFS = Recursive Best-First Search Like Depth-First Search
Saves f( ancestor) of current node. if f(n) > f(ancestor), returns.
While returning, replace ‘f’ of path with ‘f’ of child.
Linear space, O(bd)

72. SMA* SMA* = Simplified Memory –bounded A*
Using all of the available space.
Avoid repeating states.
Expands the best child (A*). When the memory is full, deletes the worst ‘f’ and replaces new ‘f’.
If goal was available (d<memory) optimal and complete

73. RTA* Real Time A* Search We have time limitation
When the time finished and we could not find the best f(n), we choose the first f(n) in the list

74. Local search algorithms
In many optimization problems, the path to the goal is not important; solution =the goal state
State space = set of "complete" configurations
Find configuration satisfying constraints, e.g., n-queens, job scheduling, optimization problems
In such cases, we can use local search algorithms
keep a single "current" state, try to improve it

75. Local search algorithms
Advantages:
Usually uses constant additional memory
Useful in large and infinite state spaces

76. Local-minimum problem
Robot Navigation
Local-minimum problem
f(N) = h(N) = straight distance to the goal

77. What’s the Issue? Search is an iterative local procedure
Good heuristics should provide global look-ahead (at low computational cost)

78. Hill-climbing search
Like climbing a mountain by an altimeter and without map
It is also called local greedy search

79. Hill-climbing search
Problem: depending on initial state, can get stuck in local maxima

80. Hill-climbing search: 8-queens problem
h = number of pairs of queens that are attacking each other, either directly or indirectly
h = 17 for the above state

81. Hill-climbing search: 8-queens problem
A local minimum with h = 1
In 5 steps

82. Hill-climbing search
Hill-climbing search is fast, if there are few local maximums & flats
Hill-climbing depends on state space landscape.
With random initial state in 8 queen: fails 86%, finds: 14%
Not complete
With random restarting, it can be complete

83. Simulated annealing search
Idea: escape local maxima by allowing some "bad" moves but gradually decrease their frequency

84. Properties of simulated annealing search
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

85. Local beam search Keep track of k states rather than just one
Start with k randomly generated states
At each iteration, all the successors of all k states are generated
If any one is a goal state, stop; else select the k best successors from the complete list and repeat.

86. Genetic algorithms
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

87. Genetic algorithms
Fitness function: number of non-attacking pairs of queens (min = 0, max = 8 × 7/2 = 28)
24/( ) = 31%
23/( ) = 29% etc

88. Genetic algorithms

89. When to Use Search Techniques?
The search space is small, and
There is no other available techniques, or
It is not worth the effort to develop a more efficient technique
The search space is large, and
There is no other available techniques, and
There exist “good” heuristics