Solving problems by searching

Solving problems by searching
Chapter 3

Outline Problem-solving agents Problem types Problem formulation
Example problems Basic search algorithms

Which type of agent will be used and why?
goal-based agent called a problem-solving agent

Problem-solving agents
atomic representations : no internal states. structured representations are usually called planning agen Problem-solving begins with precise definitions of problems and their solutions general-purpose search algorithms that can be used to solve these problems: uninformed search algorithms that are given no information about the problem other than its definition Informed search algorithms, on the other hand, can do quite well given some guidance on where to look for solutions

An agent with several immediate options of unknown value can decide what to do by first examining future actions that eventually lead to states of known value. So we have to be more specific about properties of the environment environment is observable, so the agent always knows the current state. environment is discrete. so at any given state there are only finitely many actions to choose from. environment is known, so the agent knows which states are reached by each action. environment is deterministic, so each action has exactly one outcome.

The process of looking for a sequence of actions that reaches the goal is called search.
A search algorithm takes a problem as input and returns a solution in the form of an action sequence. So, search is the process of looking for a sequence of actions that reaches the goal. Once a solution is found, the actions it recommends can be carried out this is called the execution phase it ignores its percepts when choosing an action because it knows in advance what they will be, this called open-loop system.

Problem-solving agents

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, Bucharest

Example: Romania

Goal formulation, based on the current situation and the agent's performance measure, is the first step in problem solving. Problem formulation is the process of deciding what actions and states to consider, given a goal.

A problem can be defined formally by five components:
The initial state: starts state of agent e.g.: In(Arad). A description of the possible actions available to the agent given a particular state s, ACTIONS (s) returns the set of actions that can be executed in s. For example, from the state In(Arad), the applicable actions are: { Go(Sibiu), Go(Timisoara), Go(Zerim1)}. A description of what each action does; the formal name for this is the transition model. We also use the term successor to refer to any state reachable from a given state by a single action ; (s,a). Result(In(Arad), Go(Zeriad)) = In(Zeririd) . 1+2+3= State space

Cont. The goal test, which determines whether a given state is a goal state. Sometimes the goal is specified by an abstract property rather than an explicitly enumerated set of states. For example, in chess, the goal is to reach a state called "checkmate," A path cost function that assigns a numeric cost to each path. The problem-solving agent chooses a cost function that reflects its own performance measure. The step cost of taking action a in state s to reach state s' is denoted by c (s, a, s'). Optimal solution has the lowest path cost among all solutions Note : We assume that step costs are nonnegative.

Problem types Deterministic, fully observable  single-state problem
Agent knows exactly which state it will be in; solution is a sequence Non-observable  sensorless problem (conformant problem) Agent may have no idea where it is; solution is a sequence Nondeterministic and/or partially observable  contingency problem percepts provide new information about current state often interleave} search, execution Unknown state space  exploration problem

EXAMPLE PROBLEMS

Example Problems Toy problems (but sometimes useful)
Illustrate or exercise various problem-solving methods Concise, exact description Can be used to compare performance Examples: 8-puzzle, 8-queens problem, Cryptarithmetic, Vacuum world, Missionaries and cannibals, simple route finding Real-world problem More difficult No single, agreed-upon description Examples: Route finding, Touring and traveling salesperson problems, VLSI layout, Robot navigation, Assembly sequencing Toy problem おもちゃ問題おもちゃもんだい Illustrate 説明するせつめいする Exercise 演習えんしゅう Concise 簡潔なかんけつな Agreed 合意ごうい Description 記述きじゅつ

Toy Problems: The vacuum world
The world has only two locations Each location may or may not contain dirt The agent may be in one location or the other 8 possible world states Three possible actions: Left, Right, Suck Goal: clean up all the dirt 1 2 3 4 5 6 Problem type 問題のタイプもんだいのタイプ Vacuum cleaner 掃除機そうじき Location 場所ばしょ Suck 吸込みすいこみ 7 8

Toy Problems:The vacuum world
States: one of the 8 states given earlier Actions: move left, move right, suck Goal test: no dirt left in any square Path cost: each action costs one S R L

Example: vacuum world Single-state, start in #5. Solution?

Example: vacuum world Single-state, start in #5. Solution? [Right, Suck] Sensorless, start in {1,2,3,4,5,6,7,8} e.g., Right goes to {2,4,6,8} Solution?

Example: vacuum world Sensorless, start in {1,2,3,4,5,6,7,8} e.g., Right goes to {2,4,6,8} Solution? [Right,Suck,Left,Suck] Contingency Nondeterministic: Suck may dirty a clean carpet Partially observable: location, dirt at current location. Percept: [L, Clean], i.e., start in #5 or #7 Solution?

Example: vacuum world Sensorless, start in {1,2,3,4,5,6,7,8} e.g., Right goes to {2,4,6,8} Solution? [Right,Suck,Left,Suck] Contingency Nondeterministic: Suck may dirty a clean carpet Partially observable: location, dirt at current location. Percept: [L, Clean], i.e., start in #5 or #7 Solution? [Right, if dirt then Suck]

Single-state problem formulation
A problem is defined by four items: initial state e.g., "at Arad" actions or successor function S(x) = set of action–state pairs e.g., S(Arad) = {<Arad  Zerind, Zerind>, … goal test, can be explicit, e.g., x = "at Bucharest" implicit, e.g., Checkmate(x) path cost (additive) e.g., sum of distances, number of actions executed, etc. c(x,a,y) is the step cost, assumed to be ≥ 0 A solution is a sequence of actions leading from the initial state to a goal state

Selecting a state space
Real world is complex  state space must be abstracted for problem solving (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 = set of real paths that are solutions in the real world Each abstract action should be "easier" than the original problem

Vacuum world state space graph
actions? goal test? path cost?

Vacuum world state space graph
states? Dirt location and robot(agent) location Number of possible states : n*2n 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
Number of possible states : 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]

Example: robotic assembly
states?: real-valued coordinates of robot joint angles parts of the object to be assembled actions?: continuous motions of robot joints goal test?: complete assembly path cost?: time to execute

States: Any arrangement of 0 to 8 queens on the board is a state.
Initial state: No queens on the board. Actions: Add a queen to any empty square. Transition model: Returns the board with a queen added to the specified square. Goal test: 8 queens are on the board, none attacked. In this formulation, we have 64! possible sequences to investigate. A better formulation would prohibit placing a queen in any square that is already attacked: States: All possible arrangements of n queens (0 < n < 8), one per column in the leftmost n. columns, with no queen attacking another. Actions: Add a queen to any square in the leftmost empty column such that it is not attacked by any other queen.

There are two main kinds of formulation.
An incremental formulation involves operators that augment the state description, starting with an empty state; for the 8-queens problem, this means that each action adds a queen to the state. A complete-state formulation starts with all 8 queens on the board and moves them amend.

Real world Problems States: Each state obviously includes a location (e.g., an airport) and the current time. And may depend on previous segments, their fare bases, and their status as domestic or international also state must record extra information about these "historical" aspects. Initial state: This is specified by the user's query. Actions: Take any flight from the current location, in any seat class, leaving after the current time, leaving enough time for within-airport transfer if needed.

Transition model: The state resulting from taking a flight will have the flight's destination as the current location and the flight's arrival time as the current time. Goal test: Are we at the final destination specified by the user? Path cost: This depends on monetary cost, waiting time, flight time, customs and imigration procedures, seat quality, time of day, type of airplane, frequent-flyer mileage awards, and so on.

Tree Search A general TREE-SEARCH algorithm considers all possible paths to find a solution GRAPH-SEARCH algorithm avoids consideration of redundant paths.

Tree Search The possible action sequences starting at the initial state form a search tree with : initial state at the root; the branches are actions the nodes correspond to states in the state space of the problem. leaf node, that is, a node with no children in the tree. frontier (Open list) , the set of all leaf nodes available for expansion at any given point

Tree search algorithms
Basic idea: offline, simulated exploration of state space by generating successors of already-explored states (a.k.a.~expanding states)

Tree search example

Implementation: general tree search

Implementation: states vs. nodes
A state is a (representation of) a physical configuration A node is a data structure constituting part of a search tree includes state, parent node, action, path cost g(x), depth The Expand function creates new nodes, filling in the various fields and using the SuccessorFn of the problem to create the corresponding states.

A state corresponds to a configuration of the world.
A node is a bookkeeping data structure used to represent the search tree. A state corresponds to a configuration of the world. Thus, nodes are on particular paths, as defined by PARENT pointers, whereas states are not. Furthermore, two different nodes can contain the same world state if that state is generated via two different search paths.

Infrastructure for search algorithms
Search algorithms require a data structure to keep track of the search tree that is being constructed. For each node n of the tree, we have a structure that contains four components: n. STATE: the state in the state space to which the node corresponds; n.PARENT: the node in the search tree that generated this node; n.Action: the action that was applied to the parent to generate the node; n.PATH-COST: the cost, traditionally denoted by y(n), of the path from the initial state to the node, as indicated by the parent pointers.

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: How long does it take to find a solution?( number of nodes generated) space complexity: How much memory is needed to perform the search? (maximum number of nodes in memory) optimality: does it always find a least-cost solution? Time and space complexity in Graph are measured in terms of b: maximum branching factor of the search tree, or maximum number of successors of any node d: depth of the least-cost solution (the number of steps along the path from the root ) m: maximum depth of the state space (may be ∞)

To assess the effectiveness of a search algorithm, we can consider :
search cost— which typically depends on the time complexity but can also include a term for memory usage— or we can use the total cost, which combines the search cost and the path cost of the solution found. E.g.: In Arad to Bucharest, the search cost is the amount of time taken by the search and the solution cost is the total length of the path in kilometers. => milliseconds + kilometers Note: convert Km into seconds.

Uninformed search strategies
uninformed search also called blind search The strategies have no additional information about states beyond that provided in the problem definition. they generate successors and distinguish a goal state from a non-goal state.

Uninformed search strategies
Uninformed search strategies use only the information available in the problem definition Breadth-first search Uniform-cost search Depth-first search Depth-limited search Iterative deepening search

datatype node components: STATE, PARENT-NODE, OPERATOR, DEPTH, PATH-COST

Breadth-first search Expand shallowest unexpanded node
All edges have same cost (weight) the goal test is applied to each node when it is generated, rather than when it is selected for expansion discards any new path to a state already in the frontier or explored set Frontier is a FIFO queue, i.e., new successors go at end Implementation:

Breadth-first search Expand shallowest unexpanded node Implementation:
Frontier is a FIFO queue, i.e., new successors go at end

Close List Frontier null A B,C A,B D,E,C A,B,D E,C A,B,D,E C A,B,D,E,C F,G ,fA,B,D,E,C G

1- Put the ending node (the root node) in the queue.
2- Pull a node from the beginning of the queue and examine it. If the searched element is found in this node, quit the search and return a result. Otherwise push all the (so-far-unexamined) successors (the direct child nodes) of this node into the end of the queue, if there are any. 3- If the queue is empty, every node on the graph has been examined -- quit the search and return "not found". 4- Repeat from Step 2.

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) Worst case space complexity O( | V | + | E | ) = O(bd)

Lesson Learned from BFS
Memory requirements are bigger problem than is the execution time. Time Requirement is the major factor So exponential-Complexity search problem can’t be solved by Uninformed method for any but for smallest instances.

uniform-cost search (UCS)
expands the node n with the lowest path cost g(n). Not care about the number of steps a path has, but only about their total cost. UCS may suffer from infinite loop if it ever expands a node has 0 cost action that leading to back to the same state, (e.g.: no operation). This algorithm is also known as Dijkstra’s single-source shortest algorithm. The search begins at the root node. The search continues by visiting the next node which has the least total cost from the root. Nodes are visited in this manner until a goal state is reached.

Uniform cost search modifies the breadth-first strategy .
USC expanding the lowest-cost node on the fringe (as measured by the path cost g(n)), rather than the lowest-depth node.

goal test is applied to a node when it is selected for expansion rather than when it is first generated because : The reason is that the first goal node that is generated may be on a suboptimal path. test is added in case a better path is found to a node currently on the frontier.

Uniform-cost search Expand least-cost unexpanded node Implementation:
fringe = queue ordered by path cost Equivalent to breadth-first if step costs all equal ;(ε is small positive constant) Optimal? Yes – nodes expanded in increasing order of g(n) Time? O(b 1+(C*/ ε)) where C* is the cost of the optimal solution Space? O(b1+(C*/ ε)) >bd

Advantage: Guaranteed to find the least-cost solution. Disadvantages: Exponential storage required. open list must be kept sorted (as a priority queue). Must change cost of a node on open if a lower-cost path to it is found.

Close List Frontier null A D, B A,D B,E,F A,D,B E,F,C A,D,B, E F,C A,D,B, E, F C,G A,D,B, E, F, C G Is Goal Expand G

Depth-first search Expand deepest unexpanded node Implementation:
frontier = LIFO queue, i.e., put successors at front

Algorithmic Steps Step 1: Push the root node in the Stack. Step 2: Loop until stack is empty. Step 3: Peek the node of the stack. Step 4: If the node has unvisited child nodes, get the unvisited child node, mark it as traversed and push it on stack. Step 5: If the node does not have any unvisited child nodes, pop the node from the stack.

Depth-first search Expand deepest unexpanded node Implementation:
frontier = 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 breadth-first Space? O(bm), i.e., linear space! (only a single path from the root to a leaf node) Optimal? No

DFS Drawbacks can get stuck going down the wrong path
depth-first search will either get stuck in an infinite loop and never return a solution, or it may eventually find a solution path that is longer than the optimal solution. That means depth-first search is neither complete nor optimal.

Depth-limited search voids the pitfalls of depth-first search by imposing a cutoff on the maximum depth of a path. This cutoff can be implemented by using operators that keep track of the depth. e.g.: "If you are in city A and have travelled a path of less than 19 steps, then generate a new state in city B with a path length that is one greater." With this new operator set, we are guaranteed that depth-limited search is complete but not optimal. = depth-first search with depth limit L, It takes O(bL) time and O(bL) space, predetermined depth limit L Notice that depth-limited search can terminate with two kinds of failure: the standard failure value indicates no solution; the cutoff value indicates no solution within the depth limit.

Iterative deepening search
The hard part about depth-limited search is picking a good limit. Strategy that focus on choosing the best depth limit by trying all possible depth limits: d=0, then d=1, then d=2, and so on. combines the benefits of DFS and BFS It is optimal and complete, (-ve) some states are expanded multiple times.

IDDFS(root, goal) { depth = 0 while(no solution) { solution = DLS(root, goal, depth) depth = depth + 1 } return solution DLS(node, goal, depth) if ( depth >= 0 ) { if ( node == goal ) return node for each child in expand(node) DLS(child, goal, depth-1)

Iterative deepening search l =0

Number of nodes generated in a depth-limited search to depth d with branching factor b: NDLS = b0 + b1 + b2 + … + bd-2 + bd-1 + bd Number of nodes generated in an iterative deepening search to depth d with branching factor b: NIDS = (d+1)b0 + d b^1 + (d-1)b^2 + … + 3bd-2 +2bd-1 + 1bd For b = 10, d = 5, NDLS = , , ,000 = 111,111 NIDS = , , ,000 = 123,456 Overhead = (123, ,111)/111,111 = 11%

Properties of iterative deepening search
Complete? Yes Time? (d+1)b0 + d b1 + (d-1)b2 + … + bd = O(bd) Space? O(bd) Optimal? Yes, if step cost = 1

Summary of algorithms

Bidirectional search search both forward from the initial state j and backward from the goal, and stop when the two searches meet in the middle. solution will be found in O(2bd/2) = O(bd/2).

There are three ways to deal with repeated states, in increasing order of effectiveness and computational overhead: Do not return to the state you just came from. Have the expand function (or the operator set) refuse to generate any successor that is the same state as the node's parent. Do not create paths with cycles in them. Have the expand function (or the operator set) refuse to generate any successor of a node that is the same as any of the node's ancestors. Do not generate any state that was ever generated before. This requires every state that is generated to be kept in memory, resulting in a space complexity of O(bd), potentially. It is better to think of this as O(s), where s is the number of states in the entire state space.

So -make use of a hash table that stores all the nodes that are generated. This makes checking for repeated states reasonably efficient. The trade-off between the cost of storing and checking and the cost of extra search depends on the problem: the "loopier" the state space, the more likely it is that checking will pay off.

Repeated states Failure to detect repeated states can turn a linear problem into an exponential one!

Graph search

Summary Problem formulation usually requires abstracting away real-world details to define a state space that can feasibly be explored Variety of uninformed search strategies Iterative deepening search uses only linear space and not much more time than other uninformed algorithms

Solving problems by searching

Similar presentations

Presentation on theme: "Solving problems by searching"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Solving problems by searching

Similar presentations

Presentation on theme: "Solving problems by searching"— Presentation transcript:

Similar presentations

About project

Feedback