1 / 64

721 likes | 1.39k Views

Introduction to AI Lecture 3: Uninformed Search. Problem solving by search: definitions Graph representation Graph properties and search issues Uninformed search methods depth-first search, breath-first, depth-limited search, iterative deepening search, bi-directional search. “Blind Search”.

Download Presentation
## Introduction to AI Lecture 3: Uninformed Search

**An Image/Link below is provided (as is) to download presentation**
Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.
Content is provided to you AS IS for your information and personal use only.
Download presentation by click this link.
While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.
During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

**Introduction to AILecture 3: Uninformed Search**• Problem solving by search: definitions • Graph representation • Graph properties and search issues • Uninformed search methods • depth-first search, breath-first, depth-limited search, iterative deepening search, bi-directional search. • “Blind Search” Heshaam Faili hfaili@ece.ut.ac.ir University of Tehran**formulate**search execute Problem Formulation • Goal formulation, based on the current situation and performance measure • Problem formulation is the process of deciding what actions and states to consider, given a goal. • an agent with several options can decide what to do by first examining different possible sequences of actions that lead to states of known value, and then choosing the best sequence. • This process of looking for such a sequence is called search. • search algorithm takes a problem as input and returns a solution in the form of an action sequence. • execution : Once a solution is found, the actions it recommends can be carried out**Static, Observable, Discrete, deterministic**open-loop System: when it is executing the sequence it ignores its percepts:**Problem solving by search**Represent the problem as STATES and OPERATORSthat transform one state into another state. A solution to the problem is an OPERATOR SEQUENCE that transforms the INITIAL STATE into a GOAL STATE. Finding the sequence requires SEARCHING the STATE SPACE by GENERATINGthe paths connecting the two.**Search by generating states**Initial state 3 2 100 1 4 5 Goal state 6 Operations 1 --> 2 1 -->6 2 --> 3 2 --> 5 3 --> 5 5 --> 4**Basic concepts (1)**• State: finite representation of the world at a given time. • Operator(action formulation): a function that transforms a state into another (also called rule, transition,successor function, production, action) • Initial state: world state at the beginning. • Goal state: desired world state (can be several) • Goal test: test to determine if the goal has been reached.**Basic concepts (2)**• Reachable goal: a state for which there exists a sequence of operators to reach it. • State space: set of all reachable states from initial state (possibly infinite). • Cost function: a function that assigns a cost to each operation. • Performance: • cost of the final operator sequence (path cost) • cost of finding the sequence**Problem formulation**• The first taks is to formulate the problem in terms of states and operators • Some problems can be naturally defined this way, others not! • Formulation makes a big difference! • Examples: • Vacuum world, water jug problem, tic-tac-toe, 8-puzzle, 8-queen problem, cryptoarithmetic • robot world, travelling salesman, part assembly**Vacuum World Example**• States: 2*22 = 8 • Initial state: any state … • Successor function (operators): three actions (left, right, suck) • Goal Test ? • Path test : each step cost is one ,**Example 1: water jug (1)**Given 4 and 3 liter jugs, a water pump, and a sink, how do you get exactly two liters into the 4 liter jug? 4 3 Jug 1 Jug 2 Pump Sink • State: (x,y) for liters in jugs 1 and 2, integers 0 to 4 • Operations: empty jug, fill jug, pour water between jugs • Initial state: (0,0);Goal state: (2,n)**Water jug Successor functions**amove 1. (x, y | x < 4) (4, y)Fill 4 2. (x, y | y < 3) (x, 3)Fill 3 3. (x, y | x > 0) (0, y)Dump 4 4. (x, y | y > 0) (x, 0)Dump 3 5. (x, y | x+y >=4 and y>0) (4, y - (4 - x)) Pour from 3 to 4 until 4 is full 6. (x, y | x+y >=3 and x>0) (x - (3 - y), 3) Pour from 4 to 3 until 3 is full 7. (x, y | x+y <=4 and y>0) (x+y, 0) Pour all water from 3 to 4 b move**Water Jug Problem: one solution**Gallons in y 0 3 0 3 2 2 0 Trasition Rule 2fill 3 7pour from 3 to 4 2 fill 3 5 pour from 3 to 4 until 4 is full 3 dump 4 7pour from 3 to 4**Example 2: Cryptoarithmetic**Assign numbers to letters so that the sum is correct F O R T Y + T E N + T E N S I X T Y 2 9 7 8 6 + 8 5 0 + 8 5 0 3 1 4 8 6 Solution F=2, O=9 R=7, T=8 Y=6, E=5 N=0, I=1 X=4 • State: a matrix, with letters and numbers • Operations: replace all occurrences of a letter with a digit not already there • Goal test: only digits, sum is correct**Example 3: 8-puzzle**• State: a matrix, with letters and numbers • Operation: exchange tile with adjacent empty space • Goal test: state matches final state; cost is # of moves**Example 4: 8-queens**• State: any arrangement of up to 8 queens on the board • Operation: add a queen (incremental), move a queen (fix-it) • Goal test: no queen is attacked • Improvements: only non-attacked states, place in leftmost non-attacked position (2057 possibilities instead of 648)**Some of Real Problems**• route-finding problem • Touring problems • traveling salesperson problem • VLSI layout • Robot navigation • Automatic assembly sequencing • protein design • In- Internet searching,**Graph representation**• Nodes represent states G(V,E) • Directed edges represent operation applications -- labels indicate operation applied • Initial, goal states are start and end nodes • Edge weight: cost of applying an operator • Search: find a path from start to end node • Graph is generated dynamically as we search**Graph characteristics**• A tree, directed acyclic graph, or graph with cycles -- depends on state repetitions • Number of states (n) • size of problem space, possibly infinite • Branching factor (b) • # of operations that can be applied at each state • maximum number of outgoing edges • Depth level (d) • number of edges from the initial state • the depth of the shallowest goal node; • Max path (m) • maximum length of any path in the state Space**Water jug problem: tree**b a (0,0) (0,3) (4,0) b a (4,3) (4,3) (0,0) (3,0) (0,0) (1,3) (0,3) (1,0) (4,0) (4,3) (2,0) (2,3)**Water jug problem: graph**(0,0) (4,0) (0,3) (1,3) (4,3) (3,0)**Data Structures**• State: structure with world parameters • Node: • state, depth level • # of predecesors, list of ingoing edges • # of successors, list of outgoing edges • Edge: from and to state, operation number, cost • Operation: from state, to state, matching function • Hash table of operations • Queue to keep states to be expanded**Search issues: graph generation**• Tree vs. graph • how to handle state repetitions? • what to do with infinite branches? • How to select the next state to expand • uninformed vs. informed heuristic search • Direction of expansion • from start to goal, from goal to start, both. • Efficiency • What is the most efficient way to search?**Measuring problem-solving performance**• Completeness • guarantees to find a solution if a solution exists, or return fail if none exists • Time complexity • # of operations applied in the search • Space complexity • # of nodes stored during the search • Optimality • Does the strategy find the highest-quality?**Measuring problem-solving performance**• Search Cost • Time & Memory • Path Cost • Total cost = Search Cost + Path Cost**Factors that affect search efficiency**1. More start or goal states? Move towards thelarger set G I G G I I G I**Factors that affect search efficiency**2. Branching factor: move in the direction with the lower branching factor G I I G**Uninformed search methods**• No a-priori knowledge on which node is best to expand (ex: crypto-arithmetic problem) • Depth-first search (DFS) • Breath-first search (BFS) • Uniform cost method • Depth-limited search • Iterative deepening search • Bidirectional search**A graph search problem...**4 4 A B C 3 S G 5 5 G 4 3 D E F 2 4**A**D B D A E … becomes a tree S C E E B B F 11 D F B F C E A C G 14 17 15 15 13 G C G F 19 19 17 G 25**Breath-first search**Expand the tree in successive layers, uniformly looking at all nodes at level n before progressing to level n+1 function Breath-First-Search(problem) returns solution nodes := Make-Queue(Make-Node(Initial-State(problem)) loop do if nodes is empty then return failure node := Remove-Front (nodes) if Goal-Test[problem] applied to State(node) succeeds then returnnode new-nodes := Expand (node, Operators[problem])) nodes := Insert-At-End-of-Queue(new-nodes) end**Breath-first search**S A D B D A E C E E B B F 11 D F B F C E A C G 14 17 15 15 13 G C G F 19 19 17 G 25**Number of Expanding nodes : (the goal at level d)**BFS, example**Uniform Cost search**• Breadth-first search is optimal when all step costs are equal • Uniform Cost function: an algorithm that is optimal with any step cost function. • expands the node n with the lowest path cost. • Uniform-cost search does not care about the number of steps a path has, but only about their total cost. • Infinite loop if there is zero-cost action(NoOP action)**Uniform Cost search**• Complete & Optimal if every step is greater than or equal to some small positive constant • Worst-case time & space complexity is • C* is cost of optimal solution**Depth first search**Dive into the search tree as far as you can, backing up only when there is no way to proceed function Depth-First-Search(problem) returns solution nodes := Make-Queue(Make-Node(Initial-State(problem)) loop do if nodes is empty then return failure node := Remove-Front (nodes) if Goal-Test[problem] applied to State(node) succeeds then returnnode new-nodes := Expand (node, Operarors[problem])) nodes := Insert-At-Front-of-Queue(new-nodes) end**Depth-first search**S A D B D A E C E E B B F 11 D F B F C E A C G 14 17 15 15 13 G C G F 19 19 17 G 25**Backtracking search**• A variant of depth-first search called backtracking search uses still less memory. • only one successor is generated at a time rather than all successors • Memory : O(m) compare to DFS O(bm) • Not optimal …**Depth-limited search**• Like DFS, but the search is limited to a predefined depth (L). • The depth of each state is recorded as it is generated. When picking the next state to expand, only those with depth less or equal than the current depth are expanded. • Once all the nodes of a given depth are explored, the current depth is incremented. • Complete if L>d • Time Complexity: O(bL) • Space complexity: O(bL) • L = : DFS**Depth-limited search**S depth = 3 3 A D 6 B D A E C E E B B F 11 D F B F C E A C G 14 17 15 15 13 G C G F 19 19 17 G 25**Limit can be based on knowledge of problem**• L can be determined based on the problem. • Routing in Romania with 20 cities has L = 19 • But each cites can be reached via 9 cities : L = 9 (Diameter)**IDS: Iterative deepening search**• Problem: what is a good depth limit? • Answer: make it adaptive! • Generate solutions at depth 1, 2, …. function Iterative-Deepening-Search(problem) returns solution nodes := Make-Queue(Make-Node(Initial-State(problem) for depth := 0 to infinity ifDepth-Limited-Search(problem, depth) succeeds then returnits result end return failure**Iterative deepening search**S S S A D Limit = 0 Limit = 1 S S S A D A D B D A E Limit = 2**IDS properties**• Like depth-first search, its memory requirements are O(bd) • Like breadth-first search, it is complete when the branching factor is finite and optimal when the path cost is a nondecreasing function of the depth of the node.**Iterative search is not as wasteful as it might seem**• The root subtree is computed every time instead of storing it! • BFS: b + b2 + …+ bd+ (bd+1 – b)= O(bd+1) • Repeating the search takes: (d+1)1 + (d)b + (d - 1)b2 + … (1)bd = O(bd) • IDS is faster than BFS • For b = 10 and d = 5 the number of nodes searched in DFS is 111,111 regular vs. 123,456 repeated (only 11% more) !!

More Related