Searching for Solutions
Artificial Intelligence
CMSC 25000
January 15, 2008
Agenda
• Search – Motivation
– Problem-solving agents
– Rigorous problem definitions
• Blind exhaustive search:
–
–
–
–
Breadth-first search
Uniform search
Depth-first search
Iterative deepening search
• Search analysis
– Computational cost, limitations
Problem-Solving Agents
• Goal-based agents
– Identify goal, sequence of actions that satisfy
• Goal: set of satisfying world states
– Precise specification of what to achieve
• Problem formulation:
– Identify states and actions to consider in achieving goal
– Given a set of actions, consider sequence of
actions leading to a state with some value
• Search: Process of looking for sequence
– Problem -> action sequence solution
Agent Environment Specification
●
Dimensions
–
Fully observable vs partially observable: Fully
Deterministic vs stochastic: Deterministic
–
Static vs dynamic: Static
–
Discrete vs continuous: Discrete
–
●
Issues?
Closer to Reality
• Sensorless agents (conformant problems)
– Replace state with “belief state”
• Multiple physical states, successors:sets of successors
• Partial observability (contigency problems)
– Solution is tree, branch chosen based on percepts
Example: vacuum world
• Single-state, start in
#5. Solution?
Example: vacuum world
• Single-state, start in #5.
Solution? [Right, Vacuum]
• Sensorless, start in
{1,2,3,4,5,6,7,8} e.g.,
Right goes to {2,4,6,8}
Solution?
Example: vacuum world
•
Sensorless, start in
{1,2,3,4,5,6,7,8} e.g.,
Right goes to {2,4,6,8}
Solution?
[Right,Vacuum,Left,Vacuum]
• Contingency
– Nondeterministic: Vacuum may
dirty a clean carpet
– Partially observable: location, dirt at current location.
– Percept: [L, Clean], i.e., start in #5 or #7
Solution?
Example: vacuum world
•
Sensorless, start in
{1,2,3,4,5,6,7,8} e.g.,
Right goes to {2,4,6,8}
Solution?
[Right,Vacuum,Left,Vacuum]
• Contingency
– Nondeterministic: Vacuum may
dirty a clean carpet
– Partially observable: location, dirt at current location.
– Percept: [L, Clean], i.e., start in #5 or #7
Solution? [Right, if dirt then Vacuum]
Formal Problem Definitions
• Key components:
– Initial state:
• E.g. First location
– Available actions:
• Successor function: reachable states
– Goal test:
• Conditions for goal satisfaction
– Path cost:
• Cost of sequence from initial state to reachable state
• Solution: Path from initial state to goal
– Optimal if lowest cost
Selecting a state space
• Real world is absurdly complex
 state space must be abstracted for problem solving
• (Abstract) state = set of real states
• (Abstract) action = complex combination of real actions
– e.g., "Arad  Zerind" represents a complex set of possible routes,
detours, rest stops, etc.
• For guaranteed realizability, any real state "in Arad“ must
get to some real state "in Zerind"
• (Abstract) solution =
– set of real paths that are solutions in the real world
• Each abstract action should be "easier" than the original
problem
Why Search?
• Not just city route search
– Many AI problems can be posed as search
• Planning:
– Vertices: World states; Edges: Actions
• Game-playing:
– Vertices: Board configurations; Edges: Moves
• Speech Recognition:
– Vertices: Phonemes; Edges: Phone transitions
Vacuum world state space graph
•
•
•
•
states?
actions?
goal test?
path cost?
Vacuum world state space graph
•
•
•
•
states? integer dirt and robot location
actions? Left, Right, Vacuum
goal test? no dirt at all locations
path cost? 1 per action
Example: The 8-puzzle
•
•
•
•
states?
actions?
goal test?
path cost?
Example: The 8-puzzle
•
•
•
•
states? locations of tiles
actions? move blank left, right, up, down
goal test? = goal state (given)
path cost? 1 per move
[Note: optimal solution of n-Puzzle family is NP-hard]
Example: robotic assembly
• states?: real-valued coordinates of robot joint angles, parts
of the object to be assembled
• actions?: continuous motions of robot joints
• goal test?: complete assembly
• path cost?: time to execute
Basic Search Algorithm
• Form a 1-element queue of 0 cost=root node
• Until first path in queue ends at goal or no paths
– Remove 1st path from queue; extend path one step
Paths to extend
– Reject all paths with loops
Order of paths added
– Add new paths to queue
Position new paths added
• If goal found=>success; else, failure
Basic Search Problem
• Vertices: Cities; Edges: Steps to next, distance
• Find route from S(tart) to G(oal)
4
3
S
4
A
B
5
5
4
2
D
C
G
3
4
E
F
Formal Statement
• Initial State: in(S)
• Successor function:
– Go to all neighboring nodes
• Goal state: in(G)
• Path cost:
– Sum of edge costs
Blind Search
• Need SOME route from S to G
– Assume no information known
– Depth-first search, breadth-first search,
uniform-cost search, iterative deepening search
• Convert search problem to search tree
– Root=Zero length path at Start
– Node=Path: label by terminal node
• Child one-step extension of parent path
Search Tree
S
A
D
B
C
E
D
D
A
E
B
F
B
F
G
C
G
D
E
B
E
A
F
G
F
C
G
Breadth-first Search
• Explore all paths to a given depth
S
D
A
D
A
E
E
B
F
B
B
C
D
F
D
E
E
B
A
F
C
G
Breadth-first Search Algorithm
• Form a 1-element queue of 0 cost=root node
• Until first path in queue ends at goal or no
paths
– Remove 1st path from queue; extend path one
step
– Reject all paths with loops
– Add new paths to BACK of queue
• If goal found=>success; else, failure
Analyzing Search Algorithms
• Criteria:
–
–
–
–
Completeness: Finds a solution if one exists
Optimal: Find the best (least cost) solution
Time complexity: Order of growth of running time
Space complexity: Order of growth of space needs
• BFS:
– Complete: yes; Optimal: only if # steps= cost
– Time complexity: O(b^d+1); Space: O(b^d+1)
Uniform-cost Search
• BFS:
– Extends path with fewest steps
• UCS:
– Extends path with least cost
• Analysis:
– Complete?: Yes; Optimal?: Yes
– Time: O(b^(C*/e)); Space: O(b^(C*/e))
Uniform-cost Search Algorithm
• Form a 1-element queue of 0 cost=root node
• Until first path in queue ends at goal or no
paths
– Remove 1st path from queue; extend path one
step
– Reject all paths with loops
– Add new paths to queue
– Sort paths in order of increasing length
• If goal found=>success; else, failure
Depth-first Search
• Pick a child of each node visited, go forward
– Ignore alternatives until exhaust path w/o goal
S
A
B
C
E
F
D
G
Depth-first Search Algorithm
• Form a 1-element queue of 0 cost=root node
• Until first path in queue ends at goal or no
paths
– Remove 1st path from queue; extend path one
step
– Reject all paths with loops
– Add new paths to FRONT of queue
• If goal found=>success; else, failure
Search Issues
• Breadth-first search:
– Good if many (effectively) infinite paths, b<<
– Bad if many end at same short depth, b>>
• Uniform-cost search:
– Tries paths with many short steps first
– Identical to BFS if all steps same cost
• Depth-first search:
– Good if: most partial=>complete, not too long
– Bad if many (effectively) infinite paths
Iterative Deepening
• Problem:
– DFS good space behavior
• Could go down blind path, or sub-optimal
• Solution:
– Search at progressively greater depths:
• 1,2,3,4,5…..
Progressive Deepening
• Question: Aren’t we wasting a lot of work?
– E.g. cost of intermediate depths
• Answer: (surprisingly) No!
– Most nodes at fringe
– Fringe (depth d): Cost = b^d
– Preceding depths: b^0 + b^1+…b^(d-1)
• (b^d - 1)/(b -1)
– Ratio of last ply cost/all preceding ~ b - 1
– For large branching factors, prior work small
relative to maximum depth
Heuristic Search
• A little knowledge is a powerful thing
– Order choices to explore better options first
– More knowledge => less search
– Better search alg?? Better search space
• Measure of remaining cost to goal-heuristic
– E.g. actual distance => straight-line distance
A
S
B
10.4
6.7
C
4.0
11.0
G
3.0
8.9
D
E
6.9
F
Hill-climbing Search
• Select child to expand that is closest to goal
S
10.4
A
D
10.4 A
6.7 B
8.9
E
3.0
6.9
F
G
Hill-climbing Search Algorithm
• Form a 1-element queue of 0 cost=root node
• Until first path in queue ends at goal or no
paths
– Remove 1st path from queue; extend path one
step
– Reject all paths with loops
– Sort new paths by estimated distance to goal
– Add new paths to FRONT of queue
• If goal found=>success; else, failure
Beam Search
• Breadth-first search of fixed width - top w
– Guarantees limited branching factor, E.g. w=2
S
10.4
8.9
D
A
6.7 B
D
C 4.0 E 6.9
8.9
10.4 A
E
6.9
B 3 F
6.7
A
C
G
Beam Search Algorithm
– Form a 1-element queue of 0 cost=root node
– Until first path in queue ends at goal or no paths
• Extend all paths one step
• Reject all paths with loops
• Sort all paths in queue by estimated distance to goal
– Put top w in queue
– If goal found=>success; else, failure
Best-first Search
• Expand best open node ANYWHERE in tree
– Form a 1-element queue of 0 cost=root node
– Until first path in queue ends at goal or no paths
•
•
•
•
Remove 1st path from queue; extend path one step
Reject all paths with loops
Put in queue
Sort all paths by estimated distance to goal
– If goal found=>success; else, failure
Heuristic Search Issues
• Parameter-oriented hill climbing
– Make one step adjustments to all parameters
• E.g. tuning brightness, contrast, r, g, b on TV
– Test effect on performance measure
• Problems:
– Foothill problem: aka local maximum
• All one-step changes - worse!, but not global max
– Plateau problem: one-step changes, no FOM +
– Ridge problem: all one-steps down, but not
even local max
• Solution (local max): Randomize!!
Summary
• Blind search:
– Find some path to goal
– Depth-first, Breadth-first
– Iterative Deepening
• Analyzing search algorithms
– Completeness, Optimality, Time, Space
• Next time:
– A little knowledge is a useful thing...
Search Costs
Type
Depth-first
Worst / Worst Reach
Time Space Goal?
B^d+1/ Bd
Yes
Breadth-first
B^d+1/B^d
Yes
Hill-Climbing d/ B
(no backup)
Hill-Climbing B^d+1 /Bd
No
Beam Search
Wd / WB
No
Best-first
B^d+1/B^d
Yes
Yes