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