Artificial Intelligence Exam 1
planning agents
(discussed later, these agents use a structured or factored representation of the environment)
IDA*
*iterative-depeening A*. Sets the limit to the smallest cost of an successor nodes, and then proceeds in a depth first until we can't find the limit. Saves tremendously on memory, however has a worse time complexity than A*
path cost
A component of a problem: a function that assigned a numeric cost for a path. The *step cost* is the cost of taking an action from one particular state to the next
transition model
A component of a problem: a function that maps a state and action to a next state
goal test
A component of a problem: determines whether the current state is a goal
actions
A component of a problem: possible next things that an agent can do in any state. Only some might be applicable for a particular state
initial state
A component of a problem: the state that the agent starts in
OR Node
A node in an AND-OR tree that represents the current state in the problem. At this node, we could choose next possible actions.
AND Node
A node in an AND-OR tree that represents, the possible states an environment can be after an action
consistency
A second stronger condition of the heuristic. States that h(n) ≤ c(n, a, n) + h(n'), where: n = an arbitrary node n' = successor node c(n, a, n') = cost of an action from n to success n' AKA, *monotonicity*, which in functional analysis, means the heuristic function is never not increasing or never not decreasing
Turing test
A test proposed by Alan Turing in which a machine would be judged "intelligent" if the software could use a chat conversation to fool a human into thinking it was talking with a person instead of a machine.
A* search
A type of best-first search. search based on a priority queue, where the evaluation function f(n) = g(n) + h(n) where h(n) is the heuristic and h(n) is the path cost from the start node to node n
greedy best-first search
A type of best-first search. search based on a priority queue, where the evaluation function f(n) = h(n) (i.e., the heuristic)
SMA*
A* but we have a set memory space. We expand best nodes until we run out of memory; then we delete the old nodes.
contour
Because f(n') >= f(n) (i.e., the heuristic function is nondecreasing), we can draw contours around certain node n in the graph and say that all nodes in that contour is less than f(n)
iterative-deepening search (plus, what are it's problem-solving performance measures?)
DLS, with levels going from 1 to infinity until we found the goal node Is complete Is optimal (on same conditions as BFS) TC: O(b^d) SC: O(bd)
diameter
For any graph, this give the maximum node hops to go from one arbitrary node to another for depth-limited search, this gives us an ideal choice for l
pruning
In AI, any particular nodes not explored in A* because its f(n) is larger than the C* (the cost of getting to the successor)
node
In a search tree, contain the state as well as the associated metadata
competitive multiagent
In an environment, the other agents have the same objective function than the agent ex: chess
cooperative multiagent
In an environment, the other agents might have different objective functions than the agent ex: taxi driving
thrashing
Just like OS, SMA* falls pray this problem of swapping memory in and out inefficiently
Monte Carlo simulation
MiniMax instead of going through every possibility, sample only a handful of terminal nodes As opposed to that, it could mean run a lot of random games against yourself and see which moves lead to desired outcomes
completeness
One of the 4 measures of problem-solving performance: If the solution can be found, it will be found
time complexity
One of the 4 measures of problem-solving performance: how long does it take to find the solution?
space complexity
One of the 4 measures of problem-solving performance: how much memory is needed to perform the search?
optimality
One of the 4 measures of problem-solving performance: is the solution that is found optimal?
expanding
Our successor function. Takes a node and *generates* the next states The originating node is called the *parent node* and the generated nodes are called the *child nodes*
Example of PEAS for Amazon recommendation engine
P: a count of how many recommended products the customer actually buys E: customers A: a GUI that displays recommendations in a sorted order. S: the number of buys, returns, comments that all of the customers
PEAS stands for
Performance Criteria: how to evaluate how the agent behaves Environment: everything that the agent perceives or acts upon Actuators: components that the agent has to act upon the environment Sensors: components that the agent has to sense the environment
hill-climbing search
Version: *steepest ascent* local search algorithm, in which the climber simply moves in the direction of increasing value AKA, *greedy local search*
rectangular grid
a Euclidean 2d grid. Route-finding on this grid usually causes redundant paths
linear programming
a constrained optimization problem defined by constraints being linear equalities and the objective function is also linear. the linear inequalities are known as the *convex set*
queue
a data structure for holding the frontier
plateaux
a flat area of a state-space landscape. A *shoulder* is a plateau that is not a local maximum
agent function
a function that maps the percept sequence to the an agent's actions
successor function
a function that returns all possible successors
Newton-Raphson Method
a general technique of finding the root of a function through line tangent to the function
safely explorable
a goal state is reachable by every state
problem-solving agent
a goal-based agent that uses an atomic representation of the environment in order to reach the goal
ply
a half-move. A full move would be my move and the opponent's move
admissible heuristic
a heuristic which doesn't overestimate the actual path cost Allows the A* algorithm to be optimal
precept sequence
a history of inputs that the agent has perceived
explored set
a list of all of the already explored nodes in order to prevent redundant paths AKA, a *closed list*
hessian
a matrix of second derivatives necessary for calculating the Newton-Raphson efficiently
backtracking search
a modification to DFS, in which we modify the node in memory and revert the node if a solution is not found. Has O(m) memory, as we need to keep track of the up to m actions performed on the node
expectedminimax value
a new minimax function, which incorporates a chance player that is the sum of s and r
leaf node
a node with no children nodes. Their expansion causes the frontier
local maxima
a peak higher than its neighboring states but lower than the global maximum
optimism under certainty
a principle of LRTA* actions that have not been tried in a state s are assumed to lead to goal state
exploration problem
a problem in which the agent must use its actions as experiments in order to learn
subproblem
a problem that is a subset of another problem
priority queue
a queue that pops the element with the highest priority
information gathering
a rational agent that doesn't have knowledge might have to perform actions that modify future precepts. This is _
model-based agent
a rational agent that uses precept history to create a model of the current state of the world
ridge
a sequence of local maximums that make greedy search hard to go throuh
cyclic solution
a solution for a nondeterministic problem that requires a cycle *label*: how to represent a cycle in a cyclic solution
optimal solution
a solution minimizes the path cost
coercion
a solution that works for all possible initial states
FIFO queue
a standard queue, popping the oldest out
first-choice hill climbing
a stochastic hill climbing, in which successors are randomly chosen until one is found that higher than the current one
search tree
a tree that is superimposed on the full game tree and examines enough node to determine where to move
AND-OR tree
a tree that represents the complete state-space in a non-deterministic environment
exploration
a type of information gathering in which an agent performs a series of action to get information in a "partially-observable" environment
line search
a way of adjusting the step size so that we could converge rapidly without overstepping. Way it does this is by doubling step size in the gradient direction until f is decreasing again.
sideways move
a way to combat shoulders. If all neighbors are equal height, then we should keep exploring
factored representation
a way to define the environment as a set of variables / attributes which can have values. Slightly more expressive than atomic representation, but less expressive than a structured representation
effective branching factor
a way to evaluate the A* heuristic effectiveness by noting what the branching factor would be for a particular number of visited nodes
discretization
a way to make a continuous space into a __ space, by adding a small delta value as the neighboring node. If k variables, there will be 2k neighbors for each point (correlating to +- the delta value on each variable)
incremental belief-state search
a way to solve non-observable environments, in which we solve one initial state and proceed to the next one. If it doesn't, it backtracks, finds another solution, proceeds. It does until it finds a solution that works for all the states.
execution
after a solution is found, the agent can began the action sequence. It's call this phase
learning
after the information gathering, the agent needs to do this to process and improve from what it perceives
solution
after the process of looking at sequences of possible actions (or a search), the search algorithm finds this in the terms a fixed action sequence works best in a static environment
simple reflex agent
agents that determine an action based on the current precept. Does not use a precept sequence
software agents
agents that exist only in the software world. Like the Amazon recommendation engine
uninformed search algorithms
algorithms that know nothing more about the problem other than its definition Ie, blind expands nodes, bfs/dfs/itt/depth limited
frontier
all of the unexpanded leaf nodes form this. Usually this is stored in some sort of stack, queue, or priority queue AKA: open list
LIFO queue
also known as a stack
adversary argument
an adversary constructing the state space while the agent explores by placing goals and dead ends willy nilly
agent
an agent is something that views its environment through sensors, and acts upon the environment through actuators.
interleaving
an agent that acts before it has found guaranteed plan in an nondeterministic environment is doing this
rational agent
an agent that does the right thing for any particular percept sequence, by maximizing a particular performance measure, it's dependent on what given knowledge the agent has
utility-based agent
an agent that has a function that evaluates that "happiness" of a particular state, and uses that to determine future actions
omniscient agent
an agent that is all knowing
precept
an agent's input at a given instance
fully observable
an environment in which the agent knows the complete relevant state of the environment at all times. No need for an internal state or exploration
atomic representation
an environment representation composed of wholes ex: map of cities with distance separations. In this case, the cities would be the "atoms"
utility function
an internalization of the performance measure for an agent
redundant path
another path that leads to the same node, that is usually longer than the previous path
triangle inequality
any length of the side of a triangle is less than the sum of the length of the other two sides A way to think of a consistent heuristic, with points of the triangle being n, n', and the goal state
internal state
any memory that is within an agent, for storing precept history
game
any multi agent environment, regardless if the agents are cooperative or competitive
successor
any state reachable by the current state through an action
expected utility
average utility based on a probability distribution
goal-based agent
builds on top of a model-based agent. This agent has not only a working model but a __, that describes a desired final state. With the model, the agent can choose actions that accomplish this __
empirical gradient
calculating the gradient using a small delta. Useful if the objective function is not differentiable
acting humanly
can simulate and emulate humans, so it's more familiar well known test is the Turing test
stochastic hill climbing
chooses randomly from a uphill moves, as a probability function on the hills steepness
real-world problem
compared to a toy-problem, is one whose solutions people actually care about
offline search
computing a complete solution before setting and executing the solution
random-restart hill climbing
conduct a series of hill-climbing searches from randomly generated initial states
erratic vacuum world
contrived example for the showing off nondeterministic environments
environment generator
could be a state generator, to generate possible next states from a current state. Book defines though as a way to train agents by throwing them into a particular simulated environment.
thinking rationally
creating provable correct systems. Example: constraint satisfaction problems and expert systems. Problematic in the health field due to a knowledge cliff.
problem formulation
decide what actions and states to consider, given a goal
open-loop
defines a system that ignores percepts while executing an action
depth-limited search (plus, what are it's problem-solving performance measures?)
depth-first search with a specified depth limit, call it l Is not complete Is not optimal TC: b ^ l SC: bl
known
describe an environment the laws of the physics are known
unknown
describes an environment in which the laws of physics are not known. Can be fully observable but unknown. Ex: a new video game in which you don't know the rules.
continuous
describes the way state, time, and precepts and actions in the environment are. If they are this, then they can have continuous values.
discrete
describes the way state, time, and precepts and actions in the environment are. If they are this, then they can have distinct values.
transposition
different permutation of the move sequence that end up in the same position *transposition table*: a hash table of transpositions, so that they don't have to be explored again
acting rationally
doing the best / optimal action. Usually this is based on some sort of objective function. If the objective function(s) is not aligned with human values, it might not behave humanly. Example: studying for an exam.
episodic
each sequence of action is independent from the others ex: spotting defective parts in an assembly line
8-queens problem
eight queens on a chessboard so they don't attack
uncertain
either not fully observable OR not deterministic
nondeterministic
even more extreme than stochastic, because we do not know the probability distributions of each possible outcome from an action
Sliding Block Puzzles
example is the 8-puzzle. Randomized positions for numbers, try the moves that bring them back in order
uniform-cost search (plus, what are it's problem-solving performance measures?)
expand the tree using a priority queue on order of its step cost Is complete Is always optimal TC = SC: O( b ^ (1 + C* / e) )
localization
finding out where a robot is, given a map of the world and a sequence of percepts and actions
VLSI layout problem
fitting components on board to optimize certain parameters
chance nodes
for *stochastic games* (games that combine luck and skill), the minimax must include these nodes, drawn in circles. Each {0} has an *expected value* based on its probability function
contingency plan
for a nondeterministic problem, it is if-then sequence of actions that solve the system AKA *strategy*
belief state
for a partially or non observable environment, the set of all states that the agent believes that the environment could be
goal formulation
for a problem-solving agent, determine what the desired goal is
condition-action rule
for a simple reflex agent, this is the rule that defines an action for a particular current precept
pattern database
for heuristics, we can store subproblems in this type of database, in which we know the solution and step cost. This way, our heuristics become more accurate and faster to compute
genetic programming
genetics applied to the program instead of the bit strings
unobservable
have absolutely no knowledge about the environment. Seemingly impossible, but sometimes still able to solve the problem
heavy tailed distribution
heavier tails than the exponential distribution
search strategy
how to determine which node to expand next in a search tree
search cost
how to evaluate the effectiveness of an algorithm: this is the algorithm's time complexity + (maybe memory complexity)
total cost
how to evaluate the effectiveness of an algorithm: this is the search cost + the path cost of the solution found
zero-sum game
if one person loses, the other one wins
autonomy
if the agent can learn and adapt on its own, it has this. Otherwise, the agent behaves completely on prior knowledge and is very fragile
deterministic
if the agent's actions have predictable effects. Ie, given a current state and the agent's action, we could predict the next state
dynamic
if the environment can change while the agent is deliberating. Ex: an actual Roomba room.
static
if the environment cannot change while the agent is deliberating. Ex: Our particular Roomba simulation
dead-end
if the environment is irreversible, an agent might reach this, in which no goal state is reachable.
simulated annealing
imagine a ping pong ball trying to get to the global minimum. We shake hard first (T is very high) to bump it out of local maxima. As the temperature decreases, the shaking is lowered. Implemented by randomly choosing next move. If next move is less, go. If more, then prob is related to temperature and how much worse it is.
terminal test
in a game search, checks to see if the game is over
schema
in a genetic algorithm, this refers to the substring in which some portions are unspecified. String that match this schema are called *instances* Schemas that have a high fitness functions will become more populous
step size
in a gradient ascent / gradient descent algorithm, this is the size of alpha (multiply by gradient to find Δx)
randomization
in order to prevent infinite loops, a simple reflex agent might use this in order to pick a next action
cutoff test
instead of the terminal test, if using a evaluation an evaluation function, we use this test that checks if we've reached the maximum depth
evaluation function
instead of traversing all the down a minimax tree, cut the search off early and use a heuristic this. This turns nonterminal nodes into terminal leaves
intelligent
intelligent agents are agents that behave rationally
toy problem
just a useful contrived example to illustrate AI problems
local beam search
k parallel threads that run search in their areas to generate successors. The k best are chosen for the next run. Unlike random restart, the k states talk to each other, and tell unfruitful nodes to come to them.
irreversible
leads to a infinite competitive ratio. If some actions that an exploring agent takes cannot be untaken.
LRTA*
learning real-time A*, an exploring algorithm with memory
genetic algorithm
like stochastic beam search, except instead of choosing k nodes asexually, k nodes are chosen as population, and sexually combine to form the k new start nodes on the weight of their *fitness functions* the genetic mating occurs through crossovers between two substring representation of the
stochastic beam search
like stochastic search, this is a variation of local beam search in which the next k chosen nodes is chosen randomly based on their fitness
convex optimization
linear programming is a special class of this. a constrained optimization problem in which the constraint is any convex region and the objective be any function that is convex within the region.
current node
local search operates on this, rather than on paths in the graph
monitoring
maintaining one's belief state at any time AKA *filtering*, *state estimation*
branching factor
max(the number of successors for any arbitrary node) In other words, the most children that any node can have. For example, discrete roomba has b=5 (suck, north, south, east west)
randomized behavior
might be beneficial in competitive multi agent environments in order to thwart predictability
partially observable
might have noisy inaccurate sensors, or missing data. Like our local Roomba robot.
multiagent
more than one agent in the environment ex: chess, or taxi driving
killer moves
moves that are explored first in alpha-beta pruning so as to make the algorithm more efficient
repeated state
nodes that already have been expanded that are part of the frontier again. Generating them is called generating a loopy path
optimally efficient
of all optimal algorithms with a particular heuristic function, A* is the most efficient one
single agent
only one agent in the environment (such as a crossword puzzle)
local search
operate using a single current node and move to neighbors of that node
incremental formulation
operators that augment the state description Ex: 8-queens problem, but add queens one by one in such that none of the queens are attacked
sequential
opposite of episodic ex: chess and taxi driving
gradient descent
opposite of hill climbing, find the minimization of a function
performance element
part of a learning system, this adaptive component of the learning agent takes sensor data and turns them into actions
critic
part of the learning agent, this component gives feedback from the sensors to the *learning element*, which in turns adapts the *performance element*
problem generator
part of the learning agent, this component suggests future actions that will lead to informative experiences for the learner
route-finding problem
problem defined in terms of locations and links between them
touring problem
problem defined in terms of locations and links, but also must complete a circuit (so must have the a store of visited cities)
optimization problem
problem for finding what is the optimal values for a particular objective function
constrained optimization
problem search in which certain hard constraints must be met, as well as the objective function maximized
task environments
problems spaces for which agents are the solutions. Can be specified through PEAS
random walk
randomly chooses action, will eventually find the goal or complete exploration given a finite space
metareasoning
reasoning about what computation to do. An example of this is alpha-beta pruning, in which we decided to do only a subset of computations because it was more efficient. "reasoning about reasoning"
game tree
represents state of the game and all possible next states after all actions a player or opponent takes. Can be very large
search tree
root node is initial state, nodes are possible states and edges are actions to reach those states
bidirectional search
search forward on the initial node, and backwards on the goal node
uninformed search
search strategies that have no additional information about the states provided beyond the problem definition AKA *blind search*
real-time search
searching happens in real-time
terminal states
set of states in which the game has ended
prediction
simply generating a new belief state
thinking humanly
simulating and emulating the thought processes of humans. Example: neural networks
complete-state formulation
start with the full complete state but then find a goal state Ex: 8-queens problem, start with all 8 queens on the board, and move them such that none of the queens are attacked
state space
state of states reachable from the initial state by a sequence of actions. Defined by: initial state, actions, and transition model It forms a graph. A path in the graph is the sequence of states connected by a sequence of actions
canonical form
states in this form have the same data representation if the they are equivalent This makes it possible to store the state as a hash map
informed search
strategies that know when one goal state might be more promising than the other AKA *heuristic search*
utility
the "happiness" of the agent. Ie, out of the many possible goal states that the agent could be in, which is the best
agent program
the actual implementation internally of how the agent maps an percept sequence to an action
semidynamic
the environment doesn't change; however, the time affects the agent's performance criteria score
objective function
the goal of an optimization function. Ex: reproductive fitness in nature
global minimum / maximum
the lowest and highest spot (respectively) of a state-space landscape
minimax decision
the move that chooses the optimal move for you
depth
the number of steps to the shallowest goal node
stochastic
the opposite of deterministic. Ex: taxi driving. Might have erratic traffic, action might not lead to expected consequences.
competitive ratio
the ratio of total path cost that an exploring agent traveled : the total path cost if we knew the environment in advance
abstraction
the simplified representation of a problem
object-level state space
the state space of a standard search problem, like route finding.
state-space landscape
the state-space of a local search. Has location and elevation, determined by the objective function or the cost function
Manhattan distance
the sum of horizontal and vertical displacements to its goal state AKA, *city block distance*
minimax value
the value of the move, being the defined by the minimax function Minimax algorithm is depth first
gradient
the vector of the partial derivative of the objective function with respect to each variable. Gives the magnitude and direction of the steepest increase Then, can find the maximum by setting to 0, or using gradient ascent / descent algorithm
horizon effect
there's an unavoidable move that causes serious damage, but we could temporarily avoid it. So it does stupid moves, due to an early cutoff test
separator
this type of search algorithm distinguishes nodes into two types: explored and unexplored
traveling saleperson problem
touring problem, with aim of finding shortest tour that visits every city
breadth-first search (plus, what are it's problem-solving performance measures?)
traverse the tree using a FIFO queue. Is complete Is optimal if path cost is non-decreasing TC: O(b^d) SC: O(b^d)
depth-first search (plus, what are it's problem-solving performance measures?)
traverse the tree using a LIFO queue (aka stack) Is complete in finite state spaces, as long as there is redundancy checks. Otherwise, incomplete Non optimal TC: O(b^d) SC: O(bm) Where m is the maximum length any path in the state space
structured representation
unlike factored representations, these representation stores relationships between a set of variables as well.
types of problems local search can solve
useful for optimization problems (i.e., minimize an objective function) also for continuous state problems
online search
uses interleaving, takes action, observes the environment, and computes the next action
informed search algorithm
uses node info to look for solutions Ie, uses node info or heuristics to decide what to expand next
variables
ways to define the six-dimensional space
imperfect information
we don't have all of the information beforehand, like Poker
perfect information
we have all of the information in the game beforehand, like in chess
alpha-beta pruning
when applied to a minimax, helps to prune away game states that will never be played alpha = highest-value choice we've found so far beta = lowest-value we've found so far
sensorless problem
when there is no percept information at all for the agent AKA *conformant*
Examples of AI Problems
Roomba Spam filtering Voice Assistants (like Siri) Chess and board game players
