CSE630 Homework 1: Intelligence in general, Designing Intelligent Agents

Due: October 5th at 11:59 PM
1 point late penalty for each minute late

Part 1: Intelligence and Rationality

1. (10 points) Define in your own words: a) intelligence, b) artificial intelligence, c) agent.
   
2. (10 points) Imagine you had a refrigerator that could order food for you from the market. How could you determine if the refrigerator is rational?
   
3. (10 points) Suppose you are interacting with another person in an online chat forum. A mischievous friend has told that person that you are a very advanced chatbot, so now you must try to prove that you are in fact a person rather than a chatbot. All you have available for communicating is a text-based display. How would you go about it? Would your argument focus on reasoning capabilities or sensory abilities?
   
4. (10 points) Develop a PEAS description of the task environment for (a) a robotic hospital delivery tray and (b) an autonomous Mars rover.
   
5. (10 points) Read the following stories from the Darwin Awards website located here (Warning: Some Darwin award stories contain graphic accounts of messy self-inflicted wounds. Stick to only the stories below if you are squeamish; you can substitute other stories if you wish) :
   • Freeway Dangler (2005)
   • Spy vs. self (2004)
   • Slaughterhouse Robbery (2003)
   The agent described in each of these stories has done something irrational, but using what you have learned in this class, you can give a more precise reason for why the action was irrational. For each of these three stories, identify the point of failure that prevented each of these agents from completing his task in terms of the general agent design diagram of Figure 2.13. Was the fatal mistake a failure to correctly assess what the world is like now (in other words, a failure to translate perceptions into knowledge), a failure to correctly assess which actions the agent could perform given the state of the world, or a failure to judge 'what will the world be like if I do action A'?

Part 2: Build a Simple Agent

You may write your agent from scratch or utilize the objects in the code repository provided with the textbook (with this caveat). I recommend that you draw on the pseudocode in the book to help design your agent. If you use the step names in the book such as Interpret-Input and Rule-Action (p. 47), it will be easy to extend your agent with new capabilities for future assignments.

A simple reflex agent (25 points)

Input: The percepts will be provided to the agent in a file, with one perception per line, and the perceptions will be represented as integers between 0 and 20. The agent should accept an input file from stdin so that we can test the agent with different input files. The agent needs to run at the command ReflexRover and be prepared to read the input file from standard in (without the parens around the file name of course):

> ReflexRover < (filename)

A sample input file is provided here.

We have provided a function that reads the input file and provides percepts to the agent. The code is available in C++, Perl, and Java.

Output: The agent should output the percept it received at each time step and the action it chose to perform. Output should be to stdout in exactly this format:

Perceived: X Action: (action)
An example output sequence is:
Perceived: 1 Action: NOOP
Perceived: 7 Action: GRAB
Perceived: 0 Action: NOOP
Perceived: 6 Action: GRAB

Grading: To receive full credit on this assignment, your program must have a function called SimpleReflexAgent(int percept) that returns an action, and the output produced much be appropriate given the input file we will specify for the agent when we test your program.

A reflex agent with state (25 points)

The robot still has the soil probe perception from the first part of this assignment. In addition, to plan the agent's movements, we will add a vision sensor that tells the robot whether the direction the camera is currently facing is CLEAR, meaning that the robot can move onto that position, or BOULDER, in which case the robot cannot move onto that grid position. Since the robot might damage itself running into the boulder, we want the robot to look at each location before attempting to move there. The robot must choose the direction to point the camera using the actions LOOKNORTH, LOOKSOUTH, LOOKWEST, LOOKEAST. The visual percept received by the agent depends on the direction the camera is pointing. For example, if the robot is at grid position 1,1 and looks EAST, the robot will see whether square 2,1 is clear or not. The agent should only move onto grid positions that are CLEAR.

Locations are descretized into a grid of x,y coordinates. The grid has only 2 rows (a top and bottom location) in each column. The Southern-most row is row 1 (y=1), and the Westernmost column is column 1 (x=1). The agent's movement actions are: GONORTH, GOSOUTH, GOEAST, GOWEST, in addition to the GRAB and NOOP actions from before.

Beginning from (1,1) -- a location that you hard-code -- the robot should traverse the grid and collect rock samples from each CLEAR position only when it perceives a compound that it has not previously collected. You should traverse the grid methodically, for example start at the south end of the grid and proceed by exploring each row, then moving north.

Since the agent now has two sensors, the percept for each time step will now be a 2-tupple containing the number for the soil compound located at the robot's present position, and whether the direction the robot is looking is CLEAR or BOULDER.

If the agent looks toward a direction that is outside of the defined grid (such as position (1,6) in the example), it will SEE a NULL.

Input
The input file for the agent will contain a description of a grid with either B (boulder) or a numeric soil composition in each position. Each row of the grid will be described on a separate line in this format:

row number,left position C=clear/B=boulder,left soil compound, right C=clear/B=boulder, right soil composition

A sample input file is provided here

. Once again, we have provided a function that reads the input file and provides percepts to the agent. The code is available in C++, Perl, and Java.

Here's a map corresponding to the grid in the sample input file:

--------------------------
| B  | 4  | B  | 1  | 7  |
--------------------------
| 0  | 1  | 13 | 13 | B  |
--------------------------

-------------------------------
| 1,2 | 2,2 | 3,2 | 4,2 | 5,2 |
-------------------------------
| 1,1 | 2,1 | 3,1 | 4,1 | 5,1 |
-------------------------------

> StateRover < (filename)

Output
The output should include the percept at each time step and the action chosen, as well as the position of the agent in each time step, written to stdout in exactly this format:

Position: Perceived: Action: (action), as well as a summary line showing how many compounds were collected and how many moves were made.
An example output sequence might be:
Position: <1,1> Perceived: <0,NULL> Action: LOOKNORTH
Position: <1,1> Perceived: <0,BOULDER> Action: LOOKEAST
Position: <1,1> Perceived: <0,CLEAR> Action: GOEAST
Position: <2,1> Perceived: <4,CLEAR> Action: GRAB
Position: <2,1> Perceived: <4,CLEAR> Action: LOOKWEST
Position: <2,1> Perceived: <4,CLEAR> Action: LOOKNORTH
...

Total Compounds Collected: 1 Total Moves: 1

Grading:To receive full credit on this assignment, your program should include an agent function called ReflexAgentWithState(percept) that returns an action.

Submission instructions:

Code Repository Disclaimer