Search in AI: Problem Solving by Search

Arya MirΤεχνίτη Νοημοσύνη και Ρομποτική

26 Νοε 2011 (πριν από 5 χρόνια και 7 μήνες)

1.560 εμφανίσεις

Search in AI:
Problem Solving by Search
Systematic Exploration of
Alternatives
Example Problems
States
:

Dirt and
hoover
locations

Integer location of tile
Actions
:

Left, right, suck, no-op

Move blank left, right, up,
down
Goal Test
:

No dirt

Goal state as given
Path Cost
:

1 per action, 0 for no-op

1 per move
Represent and Search

Characterise abstract representations of well-
defined problems and their solutions

state space, initial and goal states;

traverse state-space, successor function

goal test

path cost

Examples

8-puzzle, 8-queens, route-
finding,

travelling salesman, web-search, p2p file
search
Search Strategies
Blind
(independent of the domain):
depth-first, breadth-first, iterative-deepening
Heuristic
(utilises domain-specific features):
best-first, A*
Local
(if only finding goal state matters):
hill-climbing, simulated annealing, genetic
algorithm
Tree Search Algorithms

Node expansion a key idea

for exploration of state
space
How do you search for a file in your directory structure?
Tree Search Example:
From
Arad
to Bucharest
Macros: from State to Node

Node


Make-node(State)

List


Insert(Node) -- called
fringe

or
open
(graph)

List may be LIFO, FIFO,

unordered,
organised
by
some other criterion
Fringe? Later

Open

Breadth-First
Search

Expand shallowest unexpanded node

Implementation: fringe as FIFO queue
Depth-First Search

Expand deepest unexpanded node

Implementation: fringe as LIFO queue
Features for Evaluation of Strategies
i
.
Completeness
:
Does the method always find a solution?
(Is there a path from initial state to goal state?)
ii
.
Optimality
:
Does the strategy find the optimal solution?
(Does this path have lowest cost among other such paths?)
iii
.
Time Complexity
:
How long does it take?
(The number of nodes expanded.)
iv
.
Space Complexity
:
How much memory does it require?
(The number of search nodes it keeps track of.)

In CS, complexities measured in terms of graph (explicit representation); in AI
the graph is represented implicitly.

Complexity expressed in terms of
- b, the
branching factor

(
maximum number of successors of any node )
- d, the
depth
of the
shallowest goal
node
- m, the
maximum path length

in the state space
Evaluation of Breadth-first search

Assume the branching factor is uniform

b

Completeness


if shallowest goal state is at finite depth d, and
b is finite, BFS will find the goal

Optimality

--
s
hallowest goal node is not necessarily optimal; it is
optimal if
path cost is non-decreasing function of node depth

Complexity
In BFS, every node generated is held in memory

it
is either a search node or an ancestor of one.
If goal is at level d,
the
best
case scenario is

the goal

is
first node at level d; no more
nodes need to be expanded;
hence (b+b
2
+b
3
+∙ ∙ ∙+
b
d

) nodes in memory
the
worst
case: if the goal is the last one at level d; number of nodes
in memory is (b+b
2
+b
3
+∙ ∙ ∙+
b
d
+1

ʵ 
b) = O(
b
d
+1
)
Evaluation of Depth-First Search

Not optimal
: expands deepest node
first, can get stuck exploring long
(infinite) paths


Space:
Modest memory requirements
bm
+ 1 =
O(
bm
)


stores single path
from root to leaf node, plus unexpanded
nodes along the way. Once node
expanded and descendants explored,
delete from memory.

Time
:
b
m

; bad if d << m, but if solutions
are dense, better than BFS

Variant of DFS

backtracking search:
only one of b successors expanded at a
time, O(m) instead of O(
bm
)
Making use of depth-first

s memory efficiency
Iterative deepening search:
the depth-limited subroutine
Illustrating Iterative Deepening Search
Illustrating Iterative Deepening Search
Illustrating Iterative Deepening Search
Illustrating Iterative Deepening Search
Properties of IDS

Appears wasteful, revisiting same states over and over; but most states

in a
large tree are in the bottom level, so revisiting upper levels is not as wasteful as
it seems:

level d nodes are expanded once: # of nodes = (1)
b
d

,
level d

1 nodes expanded twice: # of nodes = (2)b
d

, etc.
Adding up: total # nodes generated is
(1)
b
d

+ (2)b
d

+ ∙ ∙ ∙ + (d

1)b
2
+ (d)b = O(
b
d
)

Time complexity
:
IDS generates O(
b
d
) nodes,

and so is
faster
than BFS which generates O(
b
d
+1
)
Properties of IDS
Algorithm
:
1: Do depth-first search until fixed depth D
2: If no goal node found, D++ and go to 1

Completeness:
yes

Time complexity
: IDS generates O(
b
d
) nodes

Space
: O(
bd
)

Optimal
if step cost = 1.

Preferred uninformed search method if search space is large and
the depth of solution unknown
Open and Closed Nodes

Fringe to be
explored is
called
OPEN

Instead of
discarding
nodes from
the queue,
place them
in a
CLOSED or
VISITED list

Graph
search
BFS on a graph: Goal

g

DFS on a graph: Goal

g