cs 8520: artificial intelligence intelligent agents and search paula matuszek fall, 2005 slides...

CS 8520: Artificial Intelligence

Intelligent Agents and Search

Paula Matuszek

Fall, 2005

Slides based on Hwee Tou Ng, aima.eecs.berkeley.edu/slides-ppt, which are in turn based on Russell, aima.eecs.berkeley.edu/slides-pdf.

Paula Matuszek, CSC 8520, Fall 2005. Based on aima.eecs.berkeley.edu/slides-ppt/m2-agents.ppt

Outline• Agents and environments

• Rationality

• PEAS (Performance measure, Environment, Actuators, Sensors)

• Environment types

• Agent types

Agents• An agent is anything that can be viewed as

perceiving its environment through sensors and acting upon that environment through actuators

• Human agent: eyes, ears, and other organs for sensors; hands,

• legs, mouth, and other body parts for actuators• Robotic agent: cameras and infrared range finders

for sensors;• various motors for actuators

Agents and environments

• The agent function maps from percept histories to actions:

[f: P* A]• The agent program runs on the physical

architecture to produce f• agent = architecture + program

Vacuum-cleaner world

• Percepts: location and contents, e.g., [A,Dirty]

• Actions: Left, Right, Suck, NoOp

A vacuum-cleaner agentPercept sequence Action

[A,Clean] Right

[A, Dirty] Suck

[B, Clean] Left

[B, Dirty] Suck

[A, Clean],[A, Clean] Right

[A, Clean],[A, Dirty] Suck

… …

Rational agents• An agent should strive to "do the right thing",

based on what it can perceive and the actions it can perform. The right action is the one that will cause the agent to be most successful

• Performance measure: An objective criterion for success of an agent's behavior

• E.g., performance measure of a vacuum-cleaner agent could be amount of dirt cleaned up, amount of time taken, amount of electricity consumed, amount of noise generated, etc.

Rational agents• Rational Agent: For each possible percept

sequence, a rational agent should select an action that is expected to maximize its performance measure, given the evidence provided by the percept sequence and whatever built-in knowledge the agent has.

Rational agents• Rationality is distinct from omniscience

(all-knowing with infinite knowledge)• Agents can perform actions in order to

modify future percepts so as to obtain useful information (information gathering, exploration)

• An agent is autonomous if its behavior is determined by its own experience (with ability to learn and adapt)

PEAS: Description of an Agent's World• Performance measure: How do we assess whether

we are doing the right thing?• Environment,: What is the world we are in?• Actuators: How do we affect the world we are in?• Sensors: How do we perceive the world we are in?

• Together these specify the setting for intelligent agent design

PEAS: Taxi Driver• Consider, e.g., the task of designing an

automated taxi driver:– Performance measure: Safe, fast, legal,

comfortable trip, maximize profits– Environment: Roads, other traffic, pedestrians,

customers– Actuators: Steering wheel, accelerator, brake,

signal, horn– Sensors: Cameras, sonar, speedometer, GPS,

odometer, engine sensors, keyboard

PEAS• Agent: Medical diagnosis system

• Performance measure: Healthy patient, minimize costs, lawsuits

• Environment: Patient, hospital, staff

• Actuators: Screen display (questions, tests, diagnoses, treatments, referrals)

• Sensors: Keyboard (entry of symptoms, findings, patient's answers)

PEAS• Agent: Medical diagnosis system

• Performance measure: Healthy patient, minimize costs, lawsuits

• Environment: Patient, hospital, staff

• Actuators: Screen display (questions, tests, diagnoses, treatments, referrals)

• Sensors: Keyboard (entry of symptoms, findings, patient's answers)

PEAS• Agent: Part-picking robot

• Performance measure: Percentage of parts in correct bins

• Environment: Conveyor belt with parts, bins

• Actuators: Jointed arm and hand

• Sensors: Camera, joint angle sensors

PEAS• Agent: Part-picking robot

• Performance measure: Percentage of parts in correct bins

• Environment: Conveyor belt with parts, bins

• Actuators: Jointed arm and hand

• Sensors: Camera, joint angle sensors

PEAS• Agent: Interactive English tutor

• Performance measure: Maximize student's score on test

• Environment: Set of students

• Actuators: Screen display (exercises, suggestions, corrections)

• Sensors: Keyboard

PEAS• Agent: Interactive English tutor

• Performance measure: Maximize student's score on test

• Environment: Set of students

• Actuators: Screen display (exercises, suggestions, corrections)

• Sensors: Keyboard

Environment types• Fully observable (vs. partially observable): An agent's

sensors give it access to the complete state of the environment at each point in time.

• Deterministic (vs. stochastic): The next state of the environment is completely determined by the current state and the action executed by the agent. (If the environment is deterministic except for the actions of other agents, then the environment is strategic)

• Episodic (vs. sequential): The agent's experience is divided into atomic "episodes" (each episode consists of the agent perceiving and then performing a single action), and the choice of action in each episode depends only on the episode itself.

Environment types• Static (vs. dynamic): The environment is

unchanged while an agent is deliberating. (The environment is semidynamic if the environment itself does not change with the passage of time but the agent's performance score does)

• Discrete (vs. continuous): A limited number of distinct, clearly defined percepts and actions.

• Single agent (vs. multiagent): An agent operating by itself in an environment.

Environment typesChess with Chess without Taxi a clock a clock

driving

Fully observableDeterministicEpisodicStaticDiscreteSingle agent

Environment typesChess with Chess w/out Taxi a clock a clock driving

Fully observable Yes Yes NoDeterministic Strategic Strategic No Episodic No No No Static Semi Yes No Discrete Yes Yes NoSingle agent No No No

• The environment type largely determines the agent design• The simplest environment is fully observable, deterministic, episodic, static,

discrete and single-agent.

• The real world is (of course) partially observable, stochastic, sequential, dynamic, continuous, multi-agent

Agent functions and programs• An agent is completely specified by the

agent function mapping percept sequences to actions

• One agent function (or a small equivalence class) is rational

• Aim: find a way to implement the rational agent function concisely

Table-lookup agentFunction TABLE-DRIVEN_AGENT(percept) returns an action

append percept to the end of percepts

action LOOKUP(percepts, table)

return action

• Drawbacks:– Huge table– Take a long time to build the table– No autonomy– Even with learning, need a long time for table

entries

Agent types• Four basic types in order of increasing

generality:

• Simple reflex agents

• Model-based reflex agents

• Goal-based agents

• Utility-based agents

Simple reflex agents

Simple reflex Vacuum Agentfunction REFLEX-VACUUM-AGENT ([location, status]) return

an actionif status == Dirty then return Suckelse if location == A then return Rightelse if location == B then return Left

• Observe the world, choose an action, implement action, done.

• Problems if environment is not fully-observable.• Depending on performance metric, may be

inefficient.

Model-Based Agents• Suppose moving has a cost?

• If a square stays clean once it is clean, then this algorithm will be extremely inefficient.

• A very simple improvement would be– Record when we have cleaned a square – Don’t go back once we have cleaned both.

• We have built a very simple model.

Reflex Agents with State

Reflex Agents with State More complex agent with model: a square can get dirty again.

Function REFLEX_VACUUM_AGENT_WITH_STATE ([location, status]) returns an action. last-cleaned-A and last-cleaned-B initially declared = 100.

Increment last-cleaned-A and last-cleaned-B.

if status == Dirty then return Suck

if location == A

set last-cleaned-A to 0

if last-cleaned-B > 3 then return right else no-op

set last-cleaned-B to 0

if last-cleaned-A > 3 then return left else no-op

The value we check last-cleaned against could be modified. Could track how often we find dirt to compute value

Model-Based = Reflex Plus State• Maintain an internal model of the state of

the environment

• Over time update state using world knowledge– How the world changes– How actions affect the world

• Agent can operate more efficiently

• More effective than a simple reflex agent for partially observable environments

Goal-based agents

Goal-Based Agent• Agent has some information about desirable

situations

• Needed when a single action cannot reach desired outcome

• Therefore performance measure needs to take into account "the future".

• Typical model for search and planning.

Utility-based agents

Utility-Based Agents• Possibly more than one goal, or more than

one way to reach it

• Some are better, more desirable than others

• There is a utility function which captures this notion of "better".

• Utility function maps a state or sequence of states onto a metric.

Learning agents

Learning Agents• All agents have methods for selection actions.

• Learning agents can modify these methods.

• Performance element: any of the previously described agents

• Learning element: makes changes to actions

• Critic: evaluates actions, gives feedback to learning element

• Problem generator: suggests actions

Solving problems by searching

Chapter 3

Outline• Problem-solving agents

• Problem formulation

• Example problems

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

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: 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 formulationA problem is defined by four items:

1. initial state e.g., "at Arad"2. actions or successor function S(x) = set of action–state

pairs • e.g., S(Arad) = {<Arad Zerind, Zerind>, … }

3. goal test, can be• explicit, e.g., x = "at Bucharest"• implicit, e.g., Checkmate(x)

4. 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 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

Vacuum world state space graph

• States? Actions? Goal Test? Path Cost?

Vacuum world state space graph

• states? integer dirt and robot location • 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 • 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? • actions?• goal test?• path cost?

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

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.

Search strategies• A search strategy is defined by picking the order of

node expansion. (e.g., breadth-first, depth-first) • Strategies are evaluated along the following

dimensions:– completeness: does it always find a solution if one exists?– time complexity: number of nodes generated– space complexity: maximum number of nodes in memory– optimality: does it always find a least-cost solution?

• Time and space complexity are measured 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 infinite)

Summary• We will view our systems as agents.• An agent operates in a world which can be described by its

Performance measure, Environment, Actuators, and Sensors.• A rational agent chooses actions which maximize its

performance measure, given the information it has.• Agents range in complexity from simple reflex agents to

complex utility-based agents.• Problem-solving agents search through a problem or state

space for an acceptable solution.• The formalization of a good state space is hard, and critical to

success. It must abstract the essence of the problem so that– It is easier than the real-world problem.– A solution can be found.– The solution maps back to the real-world problem and solves it.

cs 8520: artificial intelligence intelligent agents and search paula matuszek fall, 2005 slides...

agents behaviore

actuatorsrobotic agent

explorationan agent

actuatorshuman agent

pptagentsan agent

pptrational agentsan

actuatorspaula matuszek

adaptpaula matuszek

Documents

1 csc 8520 spring 2013. paula matuszek cs 8520: artificial...

©2012 paula matuszek csc 9010: text mining applications:...

eclipse (from cis.upenn/~matuszek/...

©2012 paula matuszek csc 9010: text mining applications...

©2012 paula matuszek csc 9010: text mining applications dr....

1 csc 8520 spring 2010. paula matuszek cs 8520: artificial...

artificial intelligence paula matuszek. ©2006 paula...

welcome to the computer and information technology program...

is it a heuristic?...ai class 5 (ch. 3.5-3.7) dr. cynthia...

cs 8520: artificial intelligence search paula matuszek fall,...

creating the presentation layer deco 3001 tutorial 2 –...

csc 8520 spring 2013. paula matuszek cs 8520: artificial...

csc 8520 spring 2010. paula matuszek cs 8520: artificial...

intro to cit 594 matuszek/cit594-2015.html

cs 8520: artificial intelligence robotics paula matuszek...

inference in first-order logic - university of california,...

csc 8520 spring 2010. paula matuszek cs 8520: artificial...

©2012 paula matuszek csc 9010: text mining applications:...

matuszek, kasperek.pdf

©2012 paula matuszek csc 9010: text mining applications:...