Artificial Intelligence Methods

1
Artificial Intelligence Methods

• Rao Vemuri

Searching - 2
2
Problem Definition - 1

• Initial State
• The initial state of the problem, defined in some
  suitable manner
• Operator
• A set of actions that moves the problem from one
  state to another

3
Problem Definition - 1

• Neighbourhood (Successor Function)
• The set of all possible states reachable from a
  given state
• State Space
• The set of all states reachable from the initial
  state

4
Problem Definition - 2

• Goal Test
• A test applied to a state which returns if we
  have reached a state that solves the problem
• Path Cost
• How much it costs to take a particular path

5
Problem Definition - Example
Initial State
Goal State
6
Problem Definition - Example

• States
• A description of each of the eight tiles in each
  location that it can occupy. It is also useful to
  include the blank
• Operators
• The blank moves left, right, up or down

7
Problem Definition - Example

• Goal Test
• The current state matches a certain state (e.g.
  one of the ones shown on previous slide)
• Path Cost
• Each move of the blank costs 1

8
Problem Definition - Datatype

• Datatype PROBLEM
• Components
• INITIAL-STATE,
• OPERATORS,
• GOAL-TEST,
• PATH-COST-FUNCTION

9
How Good is a Solution?

• Does our search method actually find a solution?
• Is it a good solution?
• Path Cost
• Search Cost (Time and Memory)
• Does it find the optimal solution?
• But what is optimal?

10
Evaluating a Search

• Completeness
• Is the strategy guaranteed to find a solution?
• Time Complexity
• How long does it take to find a solution?

11
Evaluating a Search

• Space Complexity
• How much memory does it take to perform the
  search?
• Optimality
• Does the strategy find the optimal solution where
  there are several solutions?

12
Search Trees
13
Search Trees

• ISSUES
• Search trees grow very quickly
• The size of the search tree is governed by the
  branching factor
• Even this simple game has a complete search tree
  of 984,410 potential nodes
• The search tree for chess has a branching factor
  of about 35

14
Implementing a Search - What we need to store

• State
• This represents the state in the state space to
  which this node corresponds
• Parent-Node
• This points to the node that generated this node.
  In a data structure representing a tree it is
  usual to call this the parent node

15
Implementing a Search - What we need to store

• Operator
• The operator that was applied to generate this
  node
• Depth
• The number of nodes from the root (i.e. the
  depth)
• Path-Cost
• The path cost from the initial state to this node

16
Implementing a Search - Datatype

• Datatype node
• Components
• STATE,
• PARENT-NODE,
• OPERATOR,
• DEPTH,
• PATH-COST

17
Using a Tree The Obvious Solution?

• Advantages
• Its intuitive
• Parents are automatically catered for

18
Using a Tree The Obvious Solution?

• But
• It can be wasteful on space
• It can be difficult the implement, particularly
  if there are varying number of children (as in
  tic-tac-toe)
• It is not always obvious which node to expand
  next. We may have to search the tree looking for
  the best leaf node (sometimes called the fringe
  or frontier nodes). This can obviously be
  computationally expensive

19
Using a Tree Maybe not so obvious

• Therefore
• It would be nice to have a simpler data
  structure to represent our tree
• And it would be nice if the next node to be
  expanded was an O(1) operation

20
Basic Queue Operations

• Make-Queue(Elements)
• Create a queue with the given elements
• Empty?(Queue)
• Returns true if the queue is empty
• Remove-Front(Queue)
• Removes the element at the head of the queue and
  returns it

21
Queue Operations - Adding Elements

• Queuing-FN(Elements,Queue)
• Inserts a set of elements into the queue.
  Different queuing functions produce different
  search algorithms.

22
General Search

• Function GENERAL-SEARCH(problem, QUEUING-FN)
  returns a solution or failure
• nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATEproblem
  ))
• Loop do
• If nodes is empty then return failure
• node REMOVE-FRONT(nodes)
• If GOAL-TESTproblem applied to STATE(node)
  succeeds then return node
• nodes QUEUING-FN(nodes,EXPAND(node,OPERATORSpro
  blem))
• End
• End Function

23
General Search

• Function GENERAL-SEARCH(problem, QUEUING-FN)
  returns a solution or failure
• nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATEproblem
  ))
• Loop do
• If nodes is empty then return failure
• node REMOVE-FRONT(nodes)
• If GOAL-TESTproblem applied to STATE(node)
  succeeds then return node
• nodes QUEUING-FN(nodes,EXPAND(node,OPERATORSpro
  blem))
• End
• End Function

24
General Search

• Function GENERAL-SEARCH(problem, QUEUING-FN)
  returns a solution or failure
• nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATEproblem
  ))
• Loop do
• If nodes is empty then return failure
• node REMOVE-FRONT(nodes)
• If GOAL-TESTproblem applied to STATE(node)
  succeeds then return node
• nodes QUEUING-FN(nodes,EXPAND(node,OPERATORSpro
  blem))
• End
• End Function

25
General Search

• Function GENERAL-SEARCH(problem, QUEUING-FN)
  returns a solution or failure
• nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATEproblem
  ))
• Loop do
• If nodes is empty then return failure
• node REMOVE-FRONT(nodes)
• If GOAL-TESTproblem applied to STATE(node)
  succeeds then return node
• nodes QUEUING-FN(nodes,EXPAND(node,OPERATORSpro
  blem))
• End
• End Function

26
General Search

• Function GENERAL-SEARCH(problem, QUEUING-FN)
  returns a solution or failure
• nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATEproblem
  ))
• Loop do
• If nodes is empty then return failure
• node REMOVE-FRONT(nodes)
• If GOAL-TESTproblem applied to STATE(node)
  succeeds then return node
• nodes QUEUING-FN(nodes,EXPAND(node,OPERATORSpro
  blem))
• End
• End Function

27
General Search

• Function GENERAL-SEARCH(problem, QUEUING-FN)
  returns a solution or failure
• nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATEproblem
  ))
• Loop do
• If nodes is empty then return failure
• node REMOVE-FRONT(nodes)
• If GOAL-TESTproblem applied to STATE(node)
  succeeds then return node
• nodes QUEUING-FN(nodes,EXPAND(node,OPERATORSpro
  blem))
• End
• End Function

28
General Search

• Function GENERAL-SEARCH(problem, QUEUING-FN)
  returns a solution or failure
• nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATEproblem
  ))
• Loop do
• If nodes is empty then return failure
• node REMOVE-FRONT(nodes)
• If GOAL-TESTproblem applied to STATE(node)
  succeeds then return node
• nodes QUEUING-FN(nodes,EXPAND(node,OPERATORSpro
  blem))
• End
• End Function

29
Artificial Intelligence Methods

• Rao Vemuri

End of Searching-2