AI mid-term I
Agent
architecture + program
What is aim of AI
find a way to implement the rational agent function concisely
Search strategies that know whether one non-goal state is expected to be better than another are called
informed search or heuristic search
General uninformed search stragtegies
1. Breadth-first search 2. Uniform-cost search 3. Depth-first search 4. Depth-limited search 5. Iterative deepening search
Properties of Task Environments
1. Fully observable (vs. partially observable) 2. Deterministic (vs. stochastic) 3. Episodic (vs. sequential) 4. Static (vs. dynamic) 5. Discrete (vs. continuous) 6. Single agent (vs. multiagent)
Discrete (vs. continuous):
A limited number of distinct, clearly defined percepts and actions
What is well-defined problems?
A problem can be defined formally by five components: Initial state Actions Transition model: description of what each action does (successor) Goal test Path cost
Agent Program vs. Agent Function
Agent program takes the current percept as input -- Nothing is available from the environment Agent function takes the entire percept history -- To do this, remember all the percepts
Episodic (vs. sequential)
Agent's experience is divided into atomic "episodes" Choice of action in each episode depends only on the episode itself
what is Agents
An agent is anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators.
what is autonomous in AI sense?
An agent is autonomous if its behavior is determined by its own experience (with ability to learn and adapt)
Single agent (vs. multiagent)
An agent operating by itself in an environment Competitive vs. cooperative
what is Rationality?
An agent should "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.
Fully observable (vs. partially observable)
An agent's sensors give it access to the complete state of the environment at each point in time.
Table-Driven Agent
Designer needs to construct a table that contains the appropriate action for every possible percept sequence
what is 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.
Explored set
Goal of explored set: contains explored states to prevent for repeated exploration
Frontier
Goal of frontier: Contain the set of discovered node(s) to expand (explore)
Simple Reflex Agent's issues
Infinite loops are often unavoidable for simple reflex agent operating in partially observable environments ■No location sensor Randomization will help A randomized simple reflex agent might outperform a deterministic simple reflex agent Better way: keep track of the part of the world it can't see now ■Maintain internal states
what is PEAS
Performance, Environment, Actuators, Sensors Specifying the task environment is always the first step in designing agent
Problem Solving Agent
Problem-solving agent: a type of goal-based agent Decide what to do by finding sequences of actions that lead to desirable states Goal formulation: based on current situation and agent's performance measure Problem formulation: deciding what actions and states to consider, given a goal The process of looking for such a sequence of actions is called search
Problem Abstraction
Real world is complex and has more details Irrelevant details should be removed from state space and actions, which is called abstraction
Five Basic Agent Types
Simple reflex agents Model-based reflex agents Goal-based agents Utility-based agents Learning agents
Five Basic Agent Types
Simple reflex agents Model-based reflex agents Goal-based agents Utility-based agents; and Learning agents
CHILD NODE Function
The CHILD-NODE function takes a parent node and an action and returns the resulting child node function CHILD-NODE(problem, parent, action) return a node return a new node with( STATE = problem.RESULT(parent.STATE, action) PARENT = parent ACTION = action PATH-COST = parent.PATH_COST + problem.STEP_COST(parent.STATE, action) )
agent program
The agent program runs on the physical architecture to produce f
Static (vs. dynamic):
The environment is unchanged while an agent is deliberating Semi-dynamic if the environment itself doesn't change with time but the agent's performance score does
The job of AI?
The job of AI is to design the agent program that implements the agent function mapping percepts to actions
A perfectly rational poker-playing agent never loses.
True
It is possible for a given agent to be perfectly rational in two distinct task environments.
True
Suppose an agent selects its action uniformly at random from the set of possible actions. There exists a deterministic task environment in which this agent is rational.
True
Uninformed Search Strategies
Uninformed search (blind search) strategies use only the information available in the problem definition
Can there be more than one agent program that implements a given agent function?
YES
Given a fixed machine architecture, does each agent program implement exactly one agent function?
YES, it implement exactly one agent function.
The environment type largely determines by
agent design
Time and space complexity are measured in terms of b, d, m
b: maximum branching factor of the search tree d: depth of the least-cost solution m: maximum depth of the state space (may be ∞)
how can count agent to be most successful?
by Performance measure: An objective criterion for success of an agent's behavior
Search Strategies terms: optimality
does it always find a least-cost solution?
Search Strategies terms: Completness
does it always find a solution if one exists? Always reach the goal state
An agent that senses only partial information about the state cannot be perfectly rational.
false
Breadth-First Search (BFS) on a graph pseudo code
function BREADTH-FIRST-SERARCH(problem) return a solution or failure node <- a node with STATE = problem.INITIAL-STATE, PATH COST =0 if problem.GOAL-TEST(node.STATE) then return SOLUTION(node) frontier <- a FIFO queue with node as the only element explored <- an empty set loop do if EMPTY?(frontier) then return failure node <- POP(frontier) /* choose the shallowest node in frontier */ add node.STATE to explored for each action in problem.ACTIONS(node.STATE) do child <-CHILD-NODE(problem, node, action) if child.STATE is not in explored or frontier then if problem.GOAL-TEST(child.STATE) then return SOLUTION (child) frontier <-INSERT(child, frontier)
General Graph Search Algorithm with memory, problem: bad memory complexity
function GRAPH-SEARCH(problem) return a solution, or failure initialize the frontier using the initial state of problem initialize the explored set to be empty loop do if the frontier is empty then return failure choose a leaf node and remove it from the frontier if the node contains a goal state then return the corresponding solution add the node to the explored set expand the chose node, adding the resulting nodes to the frontier only if not in the frontier or explored set
Simple Problem-Solving Agents
function SIMPLE-PROBLEM-SOLVING-AGENT(percept) returns an action persistent: seq, an action sequence, initially empty stat, some description of the current world state goal, a goal, initially null problem, a problem formulation state <-UPDATE-STATE(state, percept) if seq is empty then goal <-FORMULATE-GOAL(state) problem <- FORMULATE-PROBLEM(state, goal) seq <-SEARCH(problem) action <- FIRST(seq) seq <- REST(seq) return action
Simple Reflex Agent Pseduo-code
function SIMPLE-REFLEX-AGAENT(perception) returns an action static: rules, a set of condition rules state <- INTERPRET-INPUT (percept) rule <- RULE-MATCH(state, rules) action <- RULE-ACTON[rule] return action
General Tree Search Algorithm with no memory
function TREE-SEARCH(problem) return a solution, or failure initialize the frontier using the initial state of problem loop do if the frontier is empty then return failure choose a leaf node and remove it from the frontier if the node contains a goal state then return the corresponding solution expand the chosen node, adding the resulting nodes to the frontier
General Tree Search Algorithm use what type of datasstructure
heshmap, stack (frontier)
Draw back of Table-Driven Agent
huge table take a long time to construct such a table no autonomy Even with learning, need a long time to learn the table entries
what is the Distinction between rationality and omniscience
it is expected performance vs. actual performance
what is Agent function
it maps any given percept sequence to an action [f: p* → A] mathematical treatment mapping percept to action.
what is Simple Reflex Agent
it use sensor to get the perception from environment to get what the world is like now then based on condition-action rules to chose what action I should do now. It further utilized actuator to respond to environment.
Search Strategies terms: space complexity:
maximum number of nodes in memory
Deterministic (vs. stochastic)
next state of the env. determined by current state and the agent's action If the environment is deterministic except for the actions of other agents, then the environment is strategic (strategic is a subset of deterministic)
Search Strategies terms: time complexity:
number of nodes generated
what is Percept
the agent's perceptual inputs
what is Percept sequence
the complete history of everything the agent has perceived
Where does it fit into the agents and environments discussion of the Simple Problem Solver?
■ Static environment ■ Observable ■ Discrete ■ Deterministic Control System: ■ Open-loop system: percepts are ignored, thus break the loop between agent and environment ■ Closed-Loop system: with each action a percept must be taken because the world may have changed
