AI in game (II) 권태경 Fall, 2006. outline Problem-solving agent Search.
-
Upload
myron-sharp -
Category
Documents
-
view
217 -
download
2
Transcript of AI in game (II) 권태경 Fall, 2006. outline Problem-solving agent Search.
AI in game (II)
권태경Fall, 2006
outline
• Problem-solving agent
• Search
Problem-solving agent• One kind of goal-based agent
• Finds a sequence of actions– That leads to desirable states
• Needs to do– Goal formulation
• Current situation and performance measure
– Problem formulation• The process of deciding what actions and states to
consider, given a goal• Level of detail
Problem-solving agent
Example: Romania
• On holiday in Romania; currently in Arad• Flight leaves tomorrow from Bucharest• Formulate goal:
– be in Bucharest
• Formulate problem:– states: various cities– actions: drive between cities
• Find solution:– sequence of cities, e.g., Arad, Sibiu, Fagaras, Buchar
est
––
–•
Example: Romania Map
problem definition: 4 componentsA problem is defined by four items:
1. initial state e.g., “in Arad"2. actions or successor function S(x) = set of action–state pairs
– e.g., S(Arad) = {<Arad Zerind, Zerind>, … }• Or <Go(Zerind), In(Zerind)>
– Initial state and successor function define a state space (e.g. graph)3. goal test, can be
– explicit, e.g., x = “in Bucharest"– implicit, e.g., Checkmate(x)
4. path cost (additive)– c(x,a,y): step cost of action a to go from state x to state y,
• assumed to be ≥ 0– Path cost: sum of the costs of the actions along the path
• A solution is a sequence of actions leading from the initial state to a goal state
••
–
–
•
Schematic diagram
• Actions • Initial state• Goal test
state space
successor function
Problem definition in real world• Real world is absolutely 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 is valid if it is mapped to – set of real paths that are solutions in the real world
• Each abstract action should be "easier" than the original problem– usefulness
––
••
–
Vacuum world state space graph
• states?• actions?• goal test?• path cost?
•
L: go LeftR: go RightS: Suck
Vacuum world state space graph
• states? dirt (22) and robot location(2), total 8 • actions? Left, Right, Suck• 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 (9!/2)• 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]
••
15-PuzzleSam Loyd offered $1,000 of his own money to the first person who would solve the following problem:
12
14
11
15
10
13
9
5 6 7 8
4321
12
15
11
14
10
13
9
5 6 7 8
4321
?
But no one ever won the prize !!
outline
• Problem-solving agent
• Search
Solving is Searching• Solving the problem is done by a search through
the state space• A solution is a path connecting the initial node to a
goal node (any one)
I
G
Tree search algorithms• Basic idea:
– exploration of state space by generating successors of already-explored states (a.k.a.~expanding states)
–
Tree search example
• Initial state will be the root
Tree search example
• Whenever a state is generated (or visited or explored), its children nodes will be the next candidate states to explore (but not immediately!)
• Here “arad” is expanded– Children nodes are placed into the queue
Tree search example
• “sibiu” is expanded
Implementation: general tree search
fringe: the set (here, q) of visited but not expanded nodes
• Make-node(e): creates a queue with e (element)• Insert(e,q): inserts e to q (queue)• Remove-front(q) returns first(q) • InsertAll(e,q) inserts a set of elements into q
Implementation: general tree search
• The Expand function creates new nodes, filling in the various fields and using the SuccessorFn of the problem to create the corresponding states.
Implementation: states vs. nodes
• A state is a (representation of) a physical configuration• A node is a data structure constituting part of a search tr
ee includes state, parent node, action, path cost g(x), depth
Search strategies• A search strategy is defined by picking the order of node
expansion• Strategies are evaluated along the following dimensions:
– completeness: does it always find a solution if one exists?– time complexity: number of nodes generated– space complexity: maximum number of nodes in memory– optimality: does it always find a least-cost solution?
• Time and space complexity are measured in terms of – b: maximum branching factor of the search tree– d: depth of the least-cost solution– m: maximum depth of the state space (may be ∞)
––
Uninformed search strategies• Uninformed search strategies use only the
information available in the problem definition• Also called blind search• 5 approaches
– Breadth-first search– Uniform-cost search– Depth-first search– Depth-limited search– Iterative deepening search
–
–
–
–
–
•
Breadth-first search
• Expand shallowest unexpanded node
• Implementation:– fringe is a FIFO queue, i.e., new successors
go at end
–
•
Breadth-first search
• Expand shallowest unexpanded node
• Implementation:– fringe is a FIFO queue, i.e., new successors
go at end
–
•
Breadth-first search
• Expand shallowest unexpanded node
• Implementation:– fringe is a FIFO queue, i.e., new successors
go at end
–
•
Breadth-first search
• Expand shallowest unexpanded node
• Implementation:– fringe is a FIFO queue, i.e., new successors
go at end
–
•
Properties of breadth-first search
• Complete? Yes (if b is finite)• Time? 1+b+b2+b3+… +bd + b(bd-1) = O(bd+1)• Space? O(bd+1) (keeps every node in memory)• Optimal? Yes (if cost = 1 per step)
• Space is the bigger problem (more than time)
••••
•
d+1 level nodes are queued
& If the last node is goal
Uniform-cost search• Expand least-cost unexpanded node• Implementation:
– fringe = queue ordered by path cost
• Equivalent to breadth-first if step costs all equal• Complete? Yes, if step cost ≥ ε
– Should eliminate any zero-cost action
• Time? # of nodes with g() ≤ cost of optimal solution, O(b1
+C*/ ε) where C* is the cost of the optimal solution• Space? # of nodes with g() ≤ cost of optimal solution, O
(b1+C*/ ε) • Optimal? Yes – nodes expanded in increasing order of g
()
••
–•
–
•
g(x): the path cost of a node x
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Black nodes: expanded and no children nodes in memory
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Depth-first search
• Expand deepest unexpanded node• Implementation:
– fringe = LIFO queue, i.e., put successors at front
–
•
Properties of depth-first search
• Complete? No: fails in infinite-depth spaces, spaces with loops– Modify to avoid repeated states along path
complete in finite spaces
• Time? O(bm): terrible if m is much larger than d– but if solutions are dense, may be much faster than b
readth-first
• Space? O(bm), i.e., linear space!• Optimal? No
••
–•
–
m: the maximum depth of the tree
Depth-limited search
= depth-first search with depth limit l,
i.e., nodes at depth l have no successors