cs 541 artificial intelligence l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CS 541: Artificial Intelligence PowerPoint Presentation
Download Presentation
CS 541: Artificial Intelligence

Loading in 2 Seconds...

play fullscreen
1 / 93

CS 541: Artificial Intelligence - PowerPoint PPT Presentation


  • 155 Views
  • Uploaded on

CS 541: Artificial Intelligence. Lecture II: Problem Solving and Search. Course Information (1). CS541 Artificial Intelligence Term : Fall 2012 Instructor : Prof. Gang Hua Class time : Wednesday 6:15pm—8:40pm Location : Babbio Center Room 210

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CS 541: Artificial Intelligence' - forrester


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
cs 541 artificial intelligence

CS 541: Artificial Intelligence

Lecture II: Problem Solving and Search

course information 1
Course Information (1)
  • CS541 Artificial Intelligence
  • Term: Fall 2012
  • Instructor: Prof. Gang Hua
  • Class time: Wednesday 6:15pm—8:40pm
  • Location: Babbio Center Room 210
  • Office Hour: Wednesday 4:00pm—5:00pm by appointment
  • Office: Lieb/Room305
  • Course Assistant: Yizhou Lin
  • Course Website:
  • http://www.cs.stevens.edu/~ghua/ghweb/ cs541_artificial_intelligence_Fall_2012.htm
re cap lecture i
Re-cap Lecture I
  • Agents interact with environments through actuators and sensors
  • The agent function describes what the agent does in all circumstances
  • The performance measure evaluates the environment sequence
  • A perfectly rational agent maximizes expected performance
  • Agent programs implement (some) agent functions
  • PEAS descriptions definetaskenvironments
  • Environments are categorized along several dimensions:
    • Observable? Deterministic? Episodic? Static? Discrete? Single-agent?
  • Several basic agent architectures exist:
    • Reflex, Reflex with state, goal-based, utility-based
outline
Outline
  • Problem-solving agents
  • Problem types
  • Problem formulation
  • Example problems
  • Basic search algorithms
problem solving agent
Problem solving agent
  • Problem-solving agents: restricted form of general agent
  • This is offline problem solving—online problem solving involves acting without complete knowledge
example romania8
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
problem types
Problem types
  • Deterministic, fully observable  single-state problem
    • Agent knows exactly which state it will be in; solution is a sequence
  • Non-observable  conformant problem
    • Agent may have no idea where it is; solution (if any) is a sequence
  • Nondeterministic and/or partially observable  contingency problem
    • Percepts provide new information about current state
    • Solution is a contingent plan or a policy
    • Often interleave search, execution
  • Unknown state space  exploration problem (“online”)
example vacuum world
Example: vacuum world
  • Single-state, start in #5. Solution??
    • [Right, Suck]
  • Conformant, start in [1,2,3,4,5,6,7,8], e.g., right to [2,4,6,8]. Solution??
    • [Right, Suck, Left, Suck]
  • Contingency, start in #5

Non-deterministic: Suck can dirty a clean carpet

Local sensing: dirt, location only.

Solution??

  • [Right, if dirt then Suck]
single state problem formulation
Single state problem formulation
  • A problem is defined by four items
    • Initial state
      • E.g., “at Arad”
    • Action or successorfunctionS(x)= set of action-state pair,
      • E.g., S(Arad)={<AradZerind, Zerind>,…}
    • Goal test, can be
      • Explicit, e.g., x=“at Bucharest”
      • Implicit, e.g., NoDirt(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
      • Leads from the initial state to a goal state
selecting a state space
Selecting a state space
  • Real world is absurdly complex
    • State space must be abstracted for problem solving
  • (Abstract) state = set of real states
  • (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
example vacuum world state space graph
Example: vacuum world state space graph
  • States??: Integer dirt and robot location (ignore dirt amount, etc..)
  • Actions??: Left, Right, Suck, NoOp
  • Goal test??: No dirt
  • Path cost??: 1 per action (0 for NoOp)
example the 8 puzzle
Example: The 8-puzzle
  • States??: Integer locations of tiles (ignore intermediate positions)
  • Actions??: Move blank left, right, up, down (ignore unjamming etc.)
  • Goal test??: =goal state (given)
  • Path cost??: 1 per move
  • [Note: optimal solution of n-Puzzle family is NP-hard]
example robotics assembly
Example: robotics assembly
  • States??: Real-valued coordinates of robot joint angles, parts of the object to be assembled
  • Actions??: Continuous motions of robot joints
  • Goal test??: Completely assembly with no robot included!
  • Path cost??: time to execute
tree search algorithm
Tree search algorithm
  • Basic idea:
    • Offline, simulated exploration of state space by generating successors of explored state (a.k.a., expanding states)
implementation states vs nodes
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 parents, children, depth, path cost g(x)
  • States do not have parents, children, depth, or path cost
  • The EXPAND function creates new nodes, filling in the various fields and using the SUCCESSORSFN of the problem to create the corresponding states
search strategy
Search strategy
  • 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 it exists?
    • Time complexity: number of nodes generated/expanded
    • Space complexity: number of nodes holds in memory
    • Optimality: does it always find a least-cost solution?
  • Time and space complexity are measure in terms of
    • b: maximum branching factor of the search tree
    • d: depth of the least-cost solution
    • m: maximum depth of the state space (may be infinity)
uninformed search strategies
Uninformed search strategies
  • Uninformed search strategies use only the information available in the problem definition
  • List of uninformed search strategies
    • Breadth-first search
    • Uniform-cost search
    • Depth-first search
    • Depth-limited search
    • Iterative deepening search
breadth first search
Breadth first search
  • Expand shallowest unexpanded node
  • Implementation:
    • fringe is a FIFO queue, i.e., newest successors go at end
breadth first search25
Breadth first search
  • Expand shallowest unexpanded node
  • Implementation:
    • fringe is a FIFO queue, i.e., newest successors go at end
breadth first search26
Breadth first search
  • Expand shallowest unexpanded node
  • Implementation:
    • fringe is a FIFO queue, i.e., newest successors go at end
breadth first search27
Breadth first search
  • Expand shallowest unexpanded node
  • Implementation:
    • fringe is a FIFO queue, i.e., newest successors go at end
properties of breadth first search
Properties of breadth-first search
  • Complete?? Yes (if b is finite)
  • Time?? 1+b +b2+b3+…+bd+b(bd-1)=O(bd+1), i.e., exp. in d
  • Space?? O(bd+1), keeps every node in memory
  • Optimal?? Yes (if cost=1 per step); not optimal in general
  • Space is the big problem; can easily generate nodes at 100M/sec so 24hrs=8640GB
uniform cost search
Uniform cost search
  • Expand least-cost unexpanded node
  • Implementation”
    • fringe=priority queue ordered by path cost, lowest first
  • Equivalent to breadth-first if step costs all equal
  • Complete?? Yes, if step cost ≥ ε
  • Time?? # of nodes with g ≤ cost of optimal solution, O(b┌C*/ ε┐) where C* is the cost of the optimal solution
  • Space?? # of nodes with g ≤ cost of optimal solution, O(b┌C*/ ε┐)
  • Optimal?? Yes – nodes expanded in increasing order of g(n)
depth first search
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search31
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search32
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search33
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search34
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search35
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search36
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search37
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search38
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search39
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search40
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
depth first search41
Depth first search
  • Expand deepest unexpanded node
  • Implementation:
    • fringe is a LIFO queue, i.e., put successors at front
properties of depth first search
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
  • Space?? O(bm), i.e., linear space
  • Optimal?? No
depth limited search
Depth limited search
  • Depth first search with depth limit l, i.e., node at depth l has no successors
iterative deepening search
Iterative deepening search
  • Iteratively run depth limited search with different depth a range of different depth limit
properties of iterative deepening search
Properties of iterative deepening search
  • Complete?? Yes
  • Time?? (d+1)b0+db1+(d-1)b2+…+bd=O(bd)
  • Space?? O(bd)
  • Optimal?? Yes, if step cost=1
    • Can be modified to explore uniform-cost tree
  • Comparison for b=10 and d=5, solution at far right leaf:

N(IDS)=6+50+400+3,000+20,000+100,000=123,456

N(BFS)=1+10+100+1,000+10,000+100,000+999,990=1,111,101

  • IDS does better because other notes at depth d are not expanded
  • BFS can be modified to apply goal test when a node is generated
repeated states
Repeated states
  • Failure to detect repeated states can turn a linear problem into an exponential one!
summary
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
  • Graph search can be exponentially more efficient than tree search
outline55
Outline
  • Informed search
    • Best first search
    • A* search
    • Heuristics
  • Non-classical search
    • Hill climbing
    • Simulated annealing
    • Genetic algorithms (briefly)
    • Local search in continuous spaces (very briefly)
review of tree search
Review of tree search
  • A strategy is defined by picking the order of node expansion
best first search
Best first search
  • Idea: using an evaluation function for each node
    • Estimate of desirability
    • Expand the most desirable unexpanded node
  • Implementation:
    • fringe is a priority queue sorted in decreasing order of desirability
  • Special case:
    • Greedy search
    • A* search
greedy search
Greedy search
  • Evaluation function h(n) (heuristic)
    • Estimate of cost from n to the closest goal
  • E.g., hSLD(n)=straight-line distance from n to Bucharest
  • Greedy search expands the node that appears to be closest to the goal
properties of greedy search
Properties of greedy search
  • Complete?? No: can get stuck in loops
    • LasiNeamtLasiNeamt (when Oradea is the goal)
  • Time?? O(bm): but a good heuristic can give dramatic improvement
  • Space?? O(bm), i.e., keep everything in memory
  • Optimal?? No
a search
A* search
  • Idea: avoid expanding paths that are already expensive
  • Evaluation function f(n)=g(n)+h(n)
    • 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
  • A* search uses an admissible heuristic
    • i.e., h(n)≤h*(n) where h*(n) is the true cost from n
    • also require h(n)≥0, so h(G)=0 for any goal G.
  • E.g., hSLD(n) never overestimates the actual road distance
  • Theorem: A* search is optimal (given h(n) is admissible in tree search, and consistent in graph search
optimality of a standard proof
Optimality of A* (standard proof)
  • Suppose some suboptimal goal G2 has been generated and is in the queue.
  • Let n be an unexpanded node on a shortest path to an optimal goal G1.
  • f(G2) = g(G2) since h(G2)=0

> g(G1) since G2 is suboptimal

≥ f(n) since h is admissible

  • Since f(G2)>f(n), A* will never select G2 for expansion before selecting n
optimality of a more useful
Optimality of A* (more useful)
  • Lemma: A* expands nodes in order of increasing f value
  • Gradually addes“f-contour”of nodes (c.f., breadth-first adds layer)
  • Contour i has all nodes f=fi, where fi<fi+1
properties of a search
Properties of A* search
  • Complete?? Yes
    • Unless there are infinitely many nodes with f<f(G)
  • Time?? Exponential in [relative error in hxlength of solution.]
  • Space?? Keep all nodes in memory
  • Optimal?? Yes – cannot expand fi+1 until fi is finished
    • A* expands all nodes with f(n)<C*
    • A* expands some nodes with f(n)=C*
    • A* expands no nodes with f(n)>C*
proof of lemma consistency
Proof of Lemma: Consistency
  • A heuristic is consistent if

h(n)≤c(n, a, n')+h(n')

  • If h is consistent, then

f(n')=g(n')+h(n')

=g(n)+c(n, a, n')+ h(n')

≥g(n)+h(n)

=f(n)

  • f(n) is non-increasing along any path
admissible heuristics
Admissible heuristics
  • E.g., 8 puzzle problem
  • h1(n): number of misplaced tiles
  • h2(n): total Manhattan distance
  • h1(s) =?? 6
  • h1(s) =?? 4+0+3+3+1+0+2+1=14
  • Why they are admissible?
dominance
Dominance
  • If h2(n)≥h1(n) for all n (both admissbile), then h2 dominates h1 and is better for search
  • Typical search cost:
    • D=14: IDS=3,473,941 nodes
    • A*(h1)=539 nodes
    • A*(h2)=113 nodes
    • D=24: IDS≈54,000,000,000 nodes
    • A*(h1)=39,135 nodes
    • A*(h2)=1,641 nodes
  • Given any admissible heurisitcsha and hb
    • h(n)=max(ha, hb) is also admissible and dominate ha and hb
relaxed problem
Relaxed problem
  • Admissible heuristics can be derived from the exact solution cost of a relaxed version of the problem
  • If the rules of the 8-puzzle are relaxed so that a tile can move anywhere, then h1(n) gives the shortest solution
  • If the rules are relaxed so that a tile can move to any adjacent square, then h2(n) gives the shortest solution
  • Key point: the optimal solution cost of a relaxed problem is no greater than the optimal solution cost of the real problem
relaxed problem79
Relaxed problem
  • Well-known example: traveling sales-person problem (TSP)
  • Find the shortest tour visiting all cities exactly once
  • Minimum spanning tree can be computed in O(n2) and is a lower bound on the shortest (open) tool
summary80
Summary
  • Heuristic functions estimate costs of shortest paths
  • Good heuristics can dramatically reduce search cost
  • Greedy best-first search expands lowest h
    • Incomplete and not always optimal
  • A* search expands lowest g + h
    • complete and optimal
    • also optimally efficient (up to tie-breaks, for forward search)
  • Admissible heuristics can be derived from exact solution of relaxed problems
local search algorithms

Local search algorithms

Beyond classical search

iterative improvement algorithms
Iterative improvement algorithms
  • In many optimization problems, path is irrelevant;
    • The goal state itself is the solution
  • Then state space = set of "complete" configurations;
    • Find optimal configuration, e.g., TSP
    • Or, find configuration satisfying constraints, e.g., timetable
  • In such cases, can use iterative improvement algorithms;
  • keep a single "current" state, try to improve it
  • Constant space, suitable for online as well as online search
example traveling salesperson problem
Example: traveling salesperson problem
  • Start with any complete tour, perform pair-wise exchanges
  • Variants of this approach get within 1% of optimal very quickly with thousands of cities
example n queens
Example: n-queens
  • Goal: put n queens on an n x n board with no two queens on the same row, column, or diagonal
  • Move a queen to reduce number of conflicts
  • Almost always solves n-queens problems almost instantaneously for very large n, e.g., n=1million
hill climbing or gradient ascent descent
Hill-climbing (or gradient ascent/descent)
  • "Like climbing Everest in thick fog with amnesia”
hill climbing
Hill climbing
  • Useful to consider state space landscape
  • Random-restart hill climbing overcomes local maxima -- trivially complete
  • Random sideways moves  escape from shoulders  loop on flat maxima
simulated annealing
Simulated annealing
  • Idea: escape local maxima by allowing some "bad" moves, but gradually decrease their size and frequency
properties of simulated annealing
Properties of simulated annealing
  • At fixed "temperature" T, state occupation probability reaches Boltzman distribution:
    • p(x) = exp{E(x)/kT}
  • T decreased slowly enough  always reach best state x
    • because exp{E(x*)/kT}/exp{E(x)/kT} = exp{(E(x*)-E(x))/kT}>>1 for small T
  • Is this necessarily an interesting guarantee??
  • Devised by Metropolis et al., 1953, for physical process modeling
  • Widely used in VLSI layout, airline scheduling, etc.
local beam search
Local beam search
  • Idea: keep k states instead of 1; choose top k of all their successors
  • Not the same as k searches run in parallel!
  • Searches that find good states recruit other searches to join them
  • Problem: quite often, all k states end up on same local hill
  • Idea: choose k successors randomly, biased towards good ones
  • Observe the close analogy to natural selection!
    • Particle swarm optimization
genetic algorithm
Genetic algorithm
  • Idea: stochastic local beam search + generate successors from pairs of states
genetic algorithm91
Genetic algorithm
  • GAs require states encoded as strings (GPs use programs)
  • Crossover helps i substrings are meaningful components
  • GAs 6= evolution: e.g., real genes encode replication machinery!
continuous state space
Continuous state space
  • Suppose we want to site three airports in Romania:
    • 6-D state space dened by (x1; y2), (x2; y2), (x3; y3)
    • Objective function f(x1; y2; x2; y2; x3; y3) = sum of squared distances from each city to nearest airport
  • Discretization methods turn continuous space into discrete space,
    • e.g., empirical gradient considers ±ᵟ change in each coordinate
  • Gradient methods compute
  • To reduce f, e.g., by
  • Sometimes can solve for exactly (e.g., with one city).
  • Newton{Raphson (1664, 1690) iterates
  • to solve , where
assignment
Assignment
  • Reading Chapter 1&2
  • Reading Chapter 3&4
  • Required:
    • Program Outcome 31.5: Given a search problem, I am able to analyze and formalize the problem (as a state space, graph, etc.) and select the appropriate search method
      • Problem 1: Russel & Norvig Book Problem 3.9 (programming needed) (4 points)
    • Program Outcome 31.11: I am able to find appropriate idealizations for converting real world problems into AI search problems formulated using the appropriate search algorithm.
      • Problem 2: Russel & Norvig Book Problem 3.2 (2 points)
    • Program outcome 31.12: I am able to implement A* and iterative deepening search. I am able to derive heuristic functions for A* search that are appropriate for a given problem.
      • Problem 3: Russel & Norvig Book Problem 3.3 (2 points)
    • Program outcome 31.9: I am able to explain important search concepts, such as the difference between informed and uninformed search, the definitions of admissible and consistent heuristics and completeness and optimality. I am able to give the time and space complexities for standard search algorithms, and write the algorithm for it.
      • Problem 4: Russel & Norvig Book Problem 3.18 (2 points)
  • Optional bonus you can gain:
    • Russel & Norvig Book Problem 4.3
      • Outlining algorithm, 1 piont
      • Real programming, 3 point