Outline

• Syllabus Recap
• Using Slidy
• What is AI
• Quiz
• Agents

Syllabus Recap

I'm back from Computer Analysis of Images and Patterns 2017! Here's a brief summary of the CS 156 Syllabus Vasudha covered last week:

• Instructor: Chris Pollett (Office: MH214, Hours: MW 5:45pm-7pm)
• Add Codes: Only given out in class as I see space become available.
• Class Homepage/Syllabus: http://www.cs.sjsu.edu/faculty/pollett/156.2.17f/
  Has Prereqs, Lectures Notes, Videos, Homeworks, Important Dates, HW Submission, Your Grades, Class Discussion Board etc.
• Topics: We survey problem solving search algorithms, constraint satisfaction problems, adverserial search algorithms, knowledge representation, planning, and learning.
• Programming Languages: Python
• Exams: 2 Midterms (15pts each), Final (20pts), dates on classpage syllabus.
• Homeworks: 5 projects (10pts each). Each will involve code and exercises. Can work in groups of up to 3.
• Quizzes: Each Monday. 1pt each, up to 10pts total. Quiz points can only be used to replace a low or missed HW score.
• In-Class Exercises: Each Wednesday. 1pt each. Need to write-up and post to class discussion board. Points can only be used to replace points lost on midterms or finals, up to half of what you lost on a given test.
• Other Details: Regrades, test accommodations, academic policies, check class homepage...

Using Slidy

• The slides for this class are HTML files which both validate as HTML 5 and pass the WAVE Accessibility Checker.
• They are made to look like slides using a Javascript called Slidy.
• The following keystrokes do useful things in Slidy:
  • h - help (see all the commands)
  • f - fullscreen (gets rid of the links at the bottom of the window
  • space - advance a slide
  • left/right arrows - forward or back a slide
  • up/down arrows - scroll within a slide
  • a - show all slides at once for printing

Artificial Intelligence is getting machines to... ?

• Act like a human. Turing (1950) proposed the Turing Test. A computer passes the test if a human interrogator after posing questions to the computer and seeing the responses cannot distinguish the responses from those of a human. Such a computer would need to be able to:
  • Do natural language processing to enable it to communicate successfully in English
  • Use some kind of knowledge representation to store what it hears
  • Be able to do automated reasoning to use the stored information to answer questions and draw conclusions.
  • Do machine learning to adapt to new circumstances and to detect and extrapolate patterns.
  The Total Turing Test is a variant of the Turing Test in which the computer/robot must "pass" as a human. This would also involve being able to do computer vision and robotics.
• Think like a human - The field of cognitive science brings together computer models from AI and experimental techniques from psychology to construct precise and testable theories of the human mind. This can further influence attempts to make computer which can simulate such a mind. The point is having a good algorithm for something doesn't necessarily mean one is doing it the way a human mind does something.
• Think rationally - this might involve algorithms for reasoning about things expressed in formal logic.
• Act rationally - algorithms that allow an agent to act to achieve the best outcome/best expected outcome possible for that agent. An agent that acts in this way is called a rational agent.

Quiz

Agents

• As we said before the quiz, rational agents are one approach to studying AI.
• In fact, it will be the first approach we will consider this semester...
• For us, an agent is anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators.
• For example:
  • A human agent has eyes, ears, and other organs for sensors and hands, legs and vocal tracts, etc for actuators.
  • A robotic agent might have cameras and infrared range finders for its sensors, and various motors for actuators.
  • A software agent receives keystrokes, file contents, and network packets as sensory inputs and acts on its environment by displaying stuff on the screen.
• A percept refers to the agent's perceptual inputs at any given instant.

Vacuum Cleaner World

• Consider a world consisting of just two locations A and B.
• The vacuum agent perceives what square it's in and whether there is dirt in the square.
• It can choose to move left, right, suck up dirt or do nothing.
• An agent function is a map from percept sequences to an action.
• We can often write out such a function using a table:

  [A, clean] Right
  [A, dirty] Suck
  [B, clean] Left
  [B, dirty] Suck
  ...
  

• What is the best way to create such a table?
• That is essentially what is involved in "programming the agent" and determines whether it is good, bad, intelligent or stupid.

Rational Agents

• What is rational at any given time depends on:
  • The performance measure that defines the criterion for success.
  • The agent's prior knowledge of the environment.
  • The actions that the agent can perform.
  • The agent's percept sequence to date.
• A rational agent is one such that:
  For each possible percept sequence, the rational agent selects an action that is expected to maximize its performance measure, given the evidence provided by the percept sequence and whatever built-in knowledge it has.

Environments for Agents

• When we described the vacuum cleaner world, we had to specify the performance measure (P), the environment (E), the agent's actuators (A), and the sensors (S).
• We group these under the heading of the task environment and call the above the PEAS description.
• In designing an agent, the first task is always to define the task environment as completely as possible.
• As an example, consider the task of making an automated taxi driver:
  • Performance -- safe, fast, legal, comfortable trip, maximize profits
  • Environment -- roads, other traffic, pedestrians, customers
  • Actuators -- steering, accelerator, brake, signal, horn, display
  • Sensors -- cameras, sonar, GPS, odometer, accelerometer, engine sensors, keyboard

Properties of Task Environments

• Fully observable vs partially observable -- whether one can see the whole environment at any given step (such as in chess) or just part of it (such as Taxi case). In the latter case, the agent needs to keep track of what it has seen of the environment
• Single agent versus multiagent -- if you have an agent when does it have to treat other objects in its environment as agents? Cross-word puzzle solving is single agent, so was our vacuum environment, chess is a competitive two agent environment, taxi-driving is a co-operative multiagent environment. Communication is often involved in a multi-agent environment, as is randomized behavior to avoid predictability.
• Deterministic versus stochastic -- if the next state is completely determined by the current state and the given action then it is said to be deterministic; otherwise, it is stochastic.
• Episodic versus sequential -- in an episodic environment, an agent's experience is divided into episodes. In each episode the agents receives a percept and then performs a single action. For example, a quality control robot might need to classify a bottle as okay or defective. This does not depend on previous bottles it has looked at. Sequential environments are ones where the agents will affect what its future actions can be. For example, chess or taxi-driving.
• Static versus dynamic -- Can the environment change while the agent is deciding what to do next? If so, the environment is dynamic; otherwise, it is static. For example, chess is static, but taxi driving is dynamic.
• Discrete versus continuous -- Are the time, percepts, and actions of the agent divided into a fixed finite number of distinct values? (discrete) Or is it better to think of these values as being floating point of arbitrary precision? (continuous)
• Known versus unknown -- In a known environment, the outcomes for all actions are given. For example, the game of solitaire is a known environment which is only partially observable. If the environment is unknown, the agent has to figure out how it works in order to make good decisions. For example, a new video game for a human agent may present an unknown environment which is fully observable.

Agent Programs

• The goal of AI is to design agent programs. These implement the agent function described earlier.
• The kind of computing device (with sensors and actuators) on which these our program runs is called the architecture of the agent.
• A complete agent = architecture + program.
• The program for the table agent we discussed earlier might be written in pseudo-code as:

  function TABLE-DRIVEN-AGENT (percept) returns an action
      persistent: percepts, a sequence, initially empty; 
                  #can think of this as a static var
                  table, a table of actions, 
                     indexed by percept sequences; 
                  #think of as a const
      append percept to the end of percepts;
      action := Lookup(percepts, table);
      return action;
  

• Usually, the table driven approach is not used because the size of the table is huge for many task environments
• For example, suppose we had an automated taxi with a 640 x 480 px camera taking 30 frames a second. Each pixel has 24 bits of color information. This gives a lookup table of size `10^(250,000,000,000)` for an hour's driving.

Kinds of Agent Programs

The key challenge of AI is to find out how to write programs that produce rational behavior from a smallish program rather than a vast table. We next look at four kinds of agent programs that embody most intelligent systems.

• Simple Reflex Agent -- these kinds of agents select actions on the basis of the current percept, ignoring the rest of the percept history. They are often defined by a sequence of condition-action rules (aka if then rules or productions). For example,

  function REFLEX-VACUUM-AGENT ([location, status]) returns as action
      if(status == Dirty) then return Suck;
      else if(location == A) then return Right;
      else if(location == B) then return Left;
  
  

• Model-based Reflex Agent -- This kind of agent uses internal states to keep track of the parts of the world it can't see now. It updates its internal state based on information about how the world evolves independent of the agent and based on how the agent's actions affect the world. The former is called the model of the agent. After updating its state, the agent finds a rule which matches the state it is in and does the rules action. Some kinds of model-based agents can be implemented with finite-automata.
• Goal-based Agents -- Sometimes the current state of the environment is not enough to decide what to do next. One also needs to know a target goal. i.e, where do we want the Taxi to go to? Search and planning algorithms might be involved in goal-based agents.
• Utility-based Agents -- A goal is a binary condition on a state: For the taxi, we are either where we wanted to go or not. You could also imagine agents that keep track of there performance by applying a utility function. The agent then wants to move in ways that will increase the expected utility of its future states.