1 / 110

COMP SCI 5400 – Introduction to Artificial Intelligence

Understand AI systems acting and thinking like humans or rationally through examples like Ultimatum Game and Rational Agents. Learn about PEAS properties, problem-solving agents, search algorithms, and complexity in AI.

aakers
Download Presentation

COMP SCI 5400 – Introduction to Artificial Intelligence

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

Presentation Transcript


  1. COMP SCI 5400 – Introduction toArtificial Intelligence general course website: http://web.mst.edu/~tauritzd/courses/intro_AI.html Dr. Daniel Tauritz (Dr. T) Department of Computer Science tauritzd@mst.edu http://web.mst.edu/~tauritzd/

  2. What is AI? Systems that… • act like humans (Turing Test) • think like humans • think rationally • act rationally Play Ultimatum Game

  3. Computer Agent • Perceives environment • Operates autonomously • Persists over prolonged periods

  4. Rational Agents • Environment • Sensors (percepts) • Actuators (actions)

  5. Rational Computer Agents • Environment • Sensors (percepts) • Actuators (actions) • Agent Function • Agent Program

  6. Rational Behavior Depends on: • Agent’s performance measure • Agent’s prior knowledge • Possible percepts and actions • Agent’s percept sequence

  7. Rational Agent Definition “For each possible percept sequence, a rational agent selects an action that is expected to maximize its performance measure, given the evidence provided by the percept sequence and any prior knowledge the agent has.”

  8. PEAS description & properties: • Fully/Partially Observable • Deterministic, Stochastic, Strategic • Episodic, Sequential • Static, Dynamic, Semi-dynamic • Discrete, Continuous • Single agent, Multiagent • Competitive, Cooperative • Known, Unknown

  9. Agent Types • Simple Reflex Agents • Model-Based Reflex Agents • Goal-Based Agents • Utility-Based Agents • Learning Agents

  10. Problem-solving agents A definition: Problem-solving agents are goal based agents that decide what to do based on an action sequence leading to a goal state.

  11. Environment Assumptions • Fully Observable • Single Agent • Discrete • Sequential • Known & Deterministic

  12. Open-loop problem-solving steps • Problem-formulation (actions & states) • Goal-formulation (states) • Search (action sequences) • Execute solution

  13. Well-defined problems • Initial state • Action set: ACTIONS(s) • Transition model: RESULT(s,a) • Goal test • Step cost: c(s,a,s’) • Path cost • Solution / optimal solution

  14. Example problems • Vacuum world • Tic-tac-toe • 8-puzzle • 8-queens problem

  15. Search trees • Root corresponds with initial state • Vacuum state space vs. search tree • Search algorithms iterate through goal testing and expanding a state until goal found • Order of state expansion is critical!

  16. function TREE-SEARCH(problem) returns solution/fail initialize frontier using initial problem state loop do if empty(frontier) then return fail choose leaf node and remove it from frontier if chosen node contains goal state then return corresponding solution expand chosen node and add resulting nodes to frontier

  17. Redundant paths • Loopy paths • Repeated states • Redundant paths

  18. function GRAPH-SEARCH(problem) returns solution/fail initialize frontier using initial problem state initialize explored set to be empty loop do if empty(frontier) then return fail choose leaf node and remove it from frontier if chosen node contains goal state then return corresponding solution add chosen node to explored set expand chosen node and add resulting nodes to frontier only if not yet in frontier or explored set

  19. Search node datastructure • n.STATE • n.PARENT-NODE • n.ACTION • n.PATH-COST States are NOT search nodes!

  20. function CHILD-NODE(problem,parent,action) returns a node return a node with: STATE = problem.RESULT(parent.STATE,action) PARENT = parent ACTION = action PATH-COST = parent.PATH-COST + problem.STEP-COST(parent.STATE,action)

  21. Frontier • Frontier = Set of leaf nodes • Implemented as a queue with ops: • EMPTY?(queue) • POP(queue) • INSERT(element,queue) • Queue types: FIFO, LIFO (stack), and priority queue

  22. Explored Set • Explored Set = Set of expanded nodes • Implemented typically as a hash table for constant time insertion & lookup

  23. Problem-solving performance • Completeness • Optimality • Time complexity • Space complexity

  24. Complexity in AI • b – branching factor • d – depth of shallowest goal node • m – max path length in state space • Time complexity: # generated nodes • Space complexity: max # nodes stored • Search cost: time + space complexity • Total cost: search + path cost

  25. Class rules for execution traces • Order in which successors are generated is counterclockwise, ending at exactly 9 o’clock • When sorting by path-cost: • nodes with equal path-cost are ordered such that earlier generated nodes have higher priority • nodes already on the frontier have higher priority than newly added nodes with equal path-cost

  26. Example state space #1

  27. Breadth First Tree Search (BFTS) • Frontier: FIFO queue • Complete: if b and d are finite • Optimal: if path-cost is non-decreasing function of depth • Time complexity: O(b^d) • Space complexity: O(b^d)

  28. Uniform Cost Search (UCS) • g(n) = lowest path-cost from start node to node n • Frontier: priority queue ordered by g(n)

  29. Depth First Tree Search (DFTS) • Frontier: LIFO queue (a.k.a. stack) • Complete: no (DGFS is complete for finite state spaces) • Optimal: no • Time complexity: O(bm) • Space complexity: O(bm) • Backtracking version of DFTS: • space complexity: O(m) • modifies rather than copies state description

  30. Depth-Limited Tree Search (DLTS) • Frontier: LIFO queue (a.k.a. stack) • Complete: not when l < d • Optimal: no • Time complexity: O(bl) • Space complexity: O(bl) • Diameter: min # steps to get from any state to any other state

  31. Diameter example 1

  32. Diameter example 2

  33. Iterative-Deepening Depth-First Tree Search (ID-DFTS) function ID-DFS(problem) returns solution/fail for depth = 0 to ∞ do result ← DLS(problem,depth) ifresult ≠ cutoff then return result • Complete: Yes, if b is finite • Optimal: Yes, if path-cost is nondecreasing function of depth • Time complexity: O(b^d) • Space complexity: O(bd)

  34. Bidirectional Search BiBFTS • Complete: Yes, if b is finite • Optimal: Not “out of the box” • Time & Space complexity: O(bd/2)

  35. Example state space #2

  36. Best First Search (BeFS) • Select node to expand based on evaluation function f(n) • Node with lowest f(n) selected as f(n) correlated with path-cost • Represent frontier with priority queue sorted in ascending order of f-values

  37. Path-cost functions • g(n) = lowest path-cost from start node to node n • h(n) = estimated non-negative path-cost of cheapest path from node n to a goal node [with h(goal)=0]

  38. Heuristics • h(n) is a heuristic function • Heuristics incorporate problem-specific knowledge • Heuristics need to be relatively efficient to compute

  39. Important BeFS algorithms • UCS: f(n) = g(n) • GBeFS: f(n) = h(n) • A*S: f(n) = g(n)+h(n)

  40. GBeFTS • Incomplete (so also not optimal) • Worst-case time and space complexity: O(bm) • Actual complexity depends on accuracy of h(n)

  41. A*S • f(n) = g(n) + h(n) • f(n): estimated cost of optimal solution through node n • if h(n) satisfies certain conditions, A*S is complete & optimal

  42. Example state space # 3

  43. Admissible heuristics • h(n) admissible if: Example: straight line distance A*TS optimal if h(n) admissible

  44. Consistent heuristics • h(n) consistent if: Consistency implies admissibility A*GS optimal if h(n) consistent

  45. A* search notes • Optimally efficient for consistent heuristics • Run-time is a function of the heuristic error • Suboptimal variants • Not strictly admissible heuristics • A* Graph Search not scalable due to memory requirements

  46. Memory-bounded heuristic search • Iterative Deepening A* (IDA*) • Recursive Best-First Search (RBFS) • IDA* and RBFS don’t use all avail. memory • Memory-bounded A* (MA*) • Simplified MA* (SMA*) • Meta-level learning aims to minimize total problem solving cost

  47. Heuristic Functions • Effective branching factor • Domination • Composite heuristics • Generating admissible heuristics from relaxed problems

  48. Sample relaxed problem • n-puzzle legal actions: Move from A to B if horizontally or vertically adjacent and B is blank Relaxed problems: • Move from A to B if adjacent • Move from A to B if B is blank • Move from A to B

More Related