Lecture 3 Problem Solving.pptx

1
IT406
Artificial Intelligence
Problem Solving (Using Search)
Harris Chikunya

2
Problem Solving (Using Search)
• When the correct action to be taken is not immediately obvious, an
agent may need to plan ahead: to consider a sequence of actions
that form a path to a goal state.
• Such an agent is called a problem-solving agent, and the
computational process it undertakes is called search.

3
Problem Solving (using Search)
• Search Terminology
 Problem Space: It is the environment in which the search takes place.
 Problem Instance: It is Initial state + Goal state
 Problem Space Graph: It represents problem state. States are shown
by nodes and operators are shown by edges.
 Depth of a problem: Length of a shortest path or shortest sequence of
operators from Initial State to goal state.
 Branching Factor: The average number of child nodes in the problem
space graph.
 Depth: Length of the shortest path from initial state to goal state.

4
The Importance of Search in AI
• It has already become clear that many of the tasks underlying AI can
be phrased in terms of a search for the solution to the problem at
hand.
• Many goal based agents are essentially problem solving agents
which must decide what to do by searching for a sequence of
actions that lead to their solutions.
• For production systems, we have seen the need to search for a
sequence of rule applications that lead to the required fact or
action.
• For neural network systems, we need to search for the set of
connection weights that will result in the required input to output
mapping.

5
Problem Types
1. Single-State problem: deterministic, accessible
 Agent knows everything about world (the exact state),
 Can calculate optimal action sequence to reach goal
state.
 E.g., playing chess. Any action will result in an exact
state

6
Problem Types
2. Multiple-state problem: deterministic, inaccessible
• Agent does not know the exact state (could be in any of the
possible states)
• May not have sensor at all
• Assume states while working towards goal state.
• E.g., walking in a dark room
• If you are at the door, going straight will lead you to the kitchen
• If you are at the kitchen, turning left leads you to the bedroom
• …

7
Problem Types
3. Contingency problem: nondeterministic, inaccessible
• Must use sensors during execution
• Solution is a tree or policy
• Often interleave search and execution
• E.g., a new skater in an arena
• Sliding problem.
• Many skaters around

8
Problem Types
• Exploration problem: unknown state space
Discover and learn about environment while taking
actions.
• E.g., Maze

9
Problem-solving Agents
• A simplified road map of part of Romania

10
Problem-Solving Agents
• GOAL FORMULATION: Goals organize behavior by limiting the
objectives and hence the actions to be considered. The agent adopts
the goal of reaching Bucharest.
• PROBLEM FORMULATION: The agent devises a description of the
states and actions necessary to reach the goal—an abstract model
of the relevant part of the world. For our agent, one good model is
to consider the actions of traveling from one city to an adjacent city
• SEARCH: Before taking any action in the real world, searches until it
finds a sequence of actions that reaches the goal. Such a sequence is
called a solution. (such as going from Arad to Sibiu to Faragas to
Bucharest), or it will find that no solution is possible.
• EXECUTION: The agent can now execute the actions in the solution,
one at a time.

11
Search Problems and Solutions
A search problem can be defined formally as follows:
 A set of possible states that the environment can be in. We call this the state
space.
 The initial state that the agent starts in. For example: Arad.
 A set of one or more goal states. Sometimes there is one goal state (e.g.,
Bucharest), sometimes there is a small of alternative goals states.
 The actions available to the agent. Given a state s, ACTIONS(s) returns a
finite set of actions that can be executed in s. For example:
ACTIONS(Arad) = {ToSibiu, ToTimisoara, ToZerind}.
 A transition model, which describes what each action does. RESULT(s,a)
returns the state that results from doing action a in state s. For example,
RESULT(Arad, ToZerind) = Zerind.
 An action cost function, denoted by ACTION-COST(s, a, s’), that gives the numeric
cost of applying action a in state s to reach state s’
A sequence of actions forms a path, and a solution is a path from the initial state to
a goal state.

12
Example Problems
• Problems can be either standardized problems or real-world
problems.
• A standardized problem is intended to illustrate or exercise various
problem solving methods.
• It can be given a concise, exact description and hence is suitable as a
benchmark for researchers to compare the performance of
algorithms.
• A real-world problem, such as robot navigation, is one whose
solutions people actually use, and whose formulation is not
standardized, because, for example, each robot has different
sensors that produce different data.

13
Standardized Problem Example 1: 8-puzzle
• STATES:
• INITIAL STATE:
• ACTIONS:
• GOAL STATE:
• ACTION COST:

14
• STATES: Location of each of the tiles
• INITIAL STATE: Any state
• ACTIONS: moving blank Left, Right, UP, Down
• GOAL STATE: does state match goal state?
• ACTION COST: Each action cost 1

15
Why search algorithms?
 8-puzzle has 362,800 states
 15-puzzle has 10^12 states
 24-puzzle has 10^25 states
So, we need a principled way to look for a solution in these huge
search spaces…

16
Standardized Problem Example 2: Vaccum World
• STATES:
• INITIAL STATE:
• ACTIONS:
• GOAL STATE:
• ACTION COST:

17
Standardized Problem Example 2: Vaccum World
• STATES: dirt or robot locations
• INITIAL STATE: Any state
• ACTIONS: Left, Right, Suck
• GOAL STATE: no dirt
• ACTION COST: Each action cost 1

18
Real-World Problems Example 1: Route
Finding problem
• Consider the airline travel problems that must be solved by a travel-
planning Web site:
• STATES: ??
• INITIAL STATE: ??
• ACTIONS: ??
• GOAL STATE: ??
• ACTION COST: ??

19
Search Algorithms
• A search algorithm takes a search problem as input and returns a
solution, or an indication of failure.
• These algorithms use a Search tree to form the various paths from
the initial state, trying to find a path that reaches a goal state.
• Each node in the search tree corresponds to a state in the state
space and the edges in the search tree corresponds to actions.
• The root of the tree corresponds to the initial state of the problem.
• The search tree may have multiple paths to (and thus multiple
nodes for) any given state, but each node in the tree has a unique
path back to the root (as in all trees).

21
Evaluation of Search strategies
• We can evaluate an algorithm’s performance in four ways:
 COMPLETENESS: Is the algorithm guaranteed to find a solution when
there is one, and to correctly report failure when there is not?
 COST OPTIMALITY: Does it find a solution with the lowest path cost of
all solutions?
 TIME COMPLEXITY: How long does it take to find a solution? This can
be measured in seconds, or more abstractly by the number of states
and actions considered.
 SPACE COMPLEXITY: How much memory is needed to perform the
search?

22
Uninformed Search Strategies
• An uninformed search algorithm is given no clue about how close a
state is to the goal(s).
• In contrast, an informed agent who knows the location of each city
knows that Sibiu is much closer to Bucharest and thus more likely to
be on the shortest path.
• Use only information available in the problem formulation
 Breadth-first
 Uniform-cost
 Depth-first
 Depth-limited
 Iterative deepening

23
Breadth-First Search
• Expand the shallowest unexpanded node
• Moves down level by level until a goal is reached

24
Example: Traveling from Arad to Bucharest

28
BFS Performance
• Search algorithms are commonly evaluated according to the following four criteria:
 Completeness: does it always find a solution if one exists?
 Time complexity: how long does it take as function of num. of nodes?
 Space complexity: how much memory does it require?
 Optimality: does it guarantee the least-cost solution?
• Time and space complexity are measured in terms of:
 b – max branching factor of the search tree
 d – depth of the least-cost solution
 m – max depth of the search tree (may be infinity)
 BFS Performance measure
• Completeness: Yes, if b is finite
• Time complexity: 1+b+b2+…+bd = O(b d), i.e., exponential in d
• Space complexity: O(b d), keeps every node in memory
• Optimality: Yes (assuming cost = 1 per step)

29
Dijkstra’s Algorithm or Uniform-Cost Search
• It explores paths in the increasing order of cost
• It always expands the least cost node
• It is identical to BFS if each transition has the same cost
• The path cost is usually taken to be the sum of the step costs

30
Romania with step costs in Km

34
UCS Performance
• Completeness: Yes
• Time complexity: # nodes with g  cost of optimal ,  O(b d)
• Space complexity: # nodes with g  cost of optimal solution,  O(b d)
• Optimality: cost optimal
g(n) is the path cost to node n
Remember:
b = branching factor
d = depth of least-cost solution

35
Depth-first search
• Always expands the deepest node in the frontier first.
• The search proceeds immediately to the deepest level of the search,
where the nodes have no successors.
• The search then goes to the deepest node that still has unexpanded
successors.

37
Performance
• Completeness: No, fails in infinite state space (yes if finite state
space)
• Time complexity: O(b m)
• Space complexity: O(b m)
• Optimality: No
Remember:
b = branching factor
m = max depth of search tree

38
Depth-limited search
• Designed to keep DFS from wandering down an infinite path
• A version of DFS in which we supply a depth limit, ℓ, and treat all
nodes at depth ℓ as if they had no successors
• The time complexity is O(𝑏ℓ)
• The space complexity is O(bℓ)
• Unfortunately, if we make a poor choice for ℓ the algorithm will fail
to reach the solution, making it incomplete again.
• Sometimes a good depth limit can be chosen based on knowledge
of the problem.

40
Iterative deepening search
• Combines the best of BFS and DFS strategies
• IDS solves the problem of picking a good value for ℓ by
trying all values: first 0, then 1, then 2, and so on—until
either a solution is found, or the depth limited search
returns the failure value rather than the cutoff value
• NB: In general, iterative deepening is the preferred
uninformed search method when the search state space is
larger than can fit in memory and the depth of the solution
is not known.

42
Informed (Heuristic) Search Strategies
• Use domain-specific hints about the location of goals
• Can find solutions more efficiently than an uninformed strategy
• The hints come in the form of a heuristic function, denoted h(n)
• h(n) = estimated cost of the cheapest path from the state at
node n to a goal state.
• For example, in route-finding problems, we can estimate the
distance from the current state to a goal by computing the straight-
line distance on the map between the two points.
 Greedy Best first
 A*
 Heuristics
 Hill-climbing
 Simulated annealing

43
Greedy best-first search
• Estimation function:
h(n) = estimate of cost from n to goal (heuristic)
• For example:
hSLD(n) = straight-line distance from n to Bucharest
• Greedy search expands first the node that appears to be closest to
the goal, according to h(n).
• This is on the grounds that it is likely to lead to a solution quickly

44
Greedy best-first search
Values of hSLD- straight-line distances to Bucharest e.g. hSLD(Arad) =
366.

46
A* search
• Uses the evaluation function
f(n) = g(n) + h(n) where:
g(n) – cost so far to reach n
h(n) – estimated cost to goal from n
f(n) – estimated total cost of path through n to goal
• We are trying to find the cheapest solution i.e. the node with the
lowest value of g(n) + h(n)
• A* search is both complete and optimal

Lecture 3 Problem Solving.pptx

More Related Content

What's hot (20)

Similar to Lecture 3 Problem Solving.pptx (20)

Recently uploaded (20)

Lecture 3 Problem Solving.pptx

Editor's Notes