| Next revision | Previous revision |
| public:t-622-arti-11-1:lab_2_materials [2011/01/17 17:45] – created angelo | public:t-622-arti-11-1:lab_2_materials [2024/04/29 13:33] (current) – external edit 127.0.0.1 |
|---|
| === Lab 2: Comparing Agent Programs (WARNING: work in progress) === | === Lab 2: Comparing Agent Programs === |
| |
| In this lab session we will finish [[public:t-622-arti-11-1:lab_1_materials|lab 1]] and write a new kind of agent program that maintains a state. | In this lab session we will finish [[public:t-622-arti-11-1:lab_1_materials|lab 1]] and write a new kind of agent program mantaining a state. |
| |
| - Start by getting the file [[http://gist.github.com/52802|agents2.lisp]]. This is largely the same file as we had for the last lab session, except some fixes to accommodate stateful agents, and code to run experiments. | - **Getting Started**:\\ Start by getting the file {{:public:t-622-arti-11-1:agents2.zip|agents2.zip}} and unzipping it into your working directory. This is largely the same file as we had for the last lab session, except some fixes to accommodate agents having a state, and code to run experiments. |
| - First finish the steps in lab 1, including | - In order to run the experiments later, you can use both functions: **random-agent-program** and **random-agent-measure** from lab 1 (that means you can copy them in the new file **agents2.lisp** =)); |
| * writing an agent that walks about randomly | - You only have to change the **random-agent-program** declaration in order to accommodate a small change in the way the function is called during experiments.<code lisp> |
| * writing a performance evaluation function that at the end gives 20 points for each clean square and deducts one point for each move made. You can get the information about made moves from the environment like this: <code lisp>(env-moves-so-far env)</code> | ;; OLD declaration |
| - After you have finished lab 1, fill in the function RANDOM-WALK-WITH-STATE, found in agents2.lisp. This should be the program of an agent that: | (defun random-agent-program (percept) |
| * Uses the STATE field of the agent struct to remember what squares are already clean. You can use this field like this: <code lisp> | ;; NEW declaration |
| (agent-state agent) ;; returns the current state | (defun random-agent-program (agent percept) |
| (setf (agent-state agent) <new value>) ;; updates the state to a new value | |
| </code> | </code> |
| * The agent should walk randomly, but it should avoid revisiting squares that are already clean. | - **Creating an Agent Program with a State**:\\ Fill in the function **RANDOM-AGENT-WITH-STATE-PROGRAM**, found in **agents2.lisp**. This should be the program of an agent that: |
| * The agent's objective should be to clean the whole environment. | * Uses the **STATE** field of the agent struct to remember what squares has already visited (and eventually cleaned). Remember you can use this field in this way: <code lisp> |
| * If the agent is sure everything is clean, it should return the action :idle | ;; HINT: getting the value of the state field in the agent structure |
| * Be careful not to be to strict, e.g. if you make it absolutely impossible for the agent to travel through clean squares - can it get in trouble so that it is unable to meet its objective? If so, find a solution. | (agent-state agent) |
| - Use the functions at the bottom of agents2.lisp to run experiments and evaluate your agent. To try your agent on all possible 3x3 environments with two dirty squares, enter this in the REPL: <code lisp> | ;; HINT: setting a new value for the state field |
| | (setf (agent-state agent) <new value>) |
| | </code> |
| | * The agent should walk **randomly**, but it should avoid revisiting squares that has already visited (and then already cleaned up). |
| | * The agent's objective is to clean the **whole** environment. |
| | * The agent should return the **'''suck''** action when visiting a dirty square otherwise one of the following actions: **'''right''**, **'''left''**, **'''up''** or **'''down''**. |
| | * If the agent is sure everything is clean, it should return the action **'''idle''** (i.e. forever). |
| | * Be careful to not being too much strict, e.g. if it is absolutely impossible for the agent to travel through clean squares. Can it get in troubles so that it is unable to meet its objective? If so, find a solution. |
| | * **NOTE 1**: when you are ready to fill in the agent program code you'll see that the agent stores the state as a list of squares id that it has seen (and clean) already. It would be useful for you to remember the following regarding lists:<code lisp> |
| | ;; HINT: getting the first item in a list |
| | CL-USER> (first '(a b c)) |
| | A |
| | </code><code lisp> |
| | ;; HINT: adding an element to a list. |
| | ;; cons takes an item and a list, and returns a new list consisting of |
| | ;; the old list with the item tacked on the front. |
| | CL-USER> (setf my-list '(a b c)) |
| | (A B C) |
| | CL-USER> (setf my-list (cons 'item my-list)) |
| | (ITEM A B C) |
| | </code><code lisp> |
| | ;; HINT: checking for a list argument. |
| | ;; consp is a predicate which is true if its argument is a list... |
| | CL-USER> (consp '(4 3 8)) |
| | T |
| | ;; ...but is not nil |
| | CL-USER> (consp nil) |
| | NIL |
| | </code> |
| | * **NOTE 2**: in order to keep track of the squares already seen, you can use two helper functions (see **agents2.lisp** for more details): **SQUARE-ID** and **GET-NEIGHBOURS**. The following picture show an example of possible 3x3 environment (**w** x **h**, **width** and **height** = 3) and how unique id are assigned to each square:\\ {{:public:t-622-arti-11-1:vacuum2-environment-2.jpg|}} |
| | - **Running Experiments**:\\ Deal with the lines at the bottom of **agents2.lisp** to run experiments and evaluate your agent. The following lines, for example, allow you to try the **EXAMPLE-AGENT-PROGRAM** on all the possible **3x3 environments** with **2 dirty squares** (that is all the permutations of 2 dirty squares out of 3x3 = 9 squares in total). For each 3x3 generated environment, the agent program is executed for **1000 steps** and then automatically turned-off. Check this out entering these few lines in the **REPL**: <code lisp> |
| | ;; HINT: remember to load the definitions in "agent2.lisp" as shown in step 7 of Lab 1. |
| (run-experiment (generate-environments 3 3 2) | (run-experiment (generate-environments 3 3 2) |
| (lambda () (make-agent :program #'random-walk-with-state)) | (lambda () (make-agent :program #'example-agent-program)) |
| #'perf-measure | #'example-measure |
| 1000) | 1000) |
| </code>This will return the number of experiments performed, and the average performance value. | </code>This will return the **number** of **experiments** performed, and the **average performance value**. |
| - Try different agents (e.g. stateless random walk) and different performance measures. Does the stateful agent behave better than the others with any particular performance measure? You can add print commands to the experiment functions to get more information about the agents behaviour if you like. | - **Comparing Different Agents**:\\ Try different agents (e.g. random-agent-program) and **different performance measures**. Does the agent with state behave better than the others with any particular performance measure? You can add print commands to the experiment functions to get more information about the agents behaviour if you like. |
| - **BONUS** If you finish the stateful agent and running the experiments, try creating an agent that moves through the environment in some orderly pattern. Make sure it visits all squares and cleans the dirty ones. Is the orderly agent more efficient than the random one? | - **Building an Orderly Agent (EXTRA)**:\\ Try to create an agent called **orderly-moving-agent-program** that moves through the environment with some orderly pattern (i.e. from left to right, then down, right to left, down and so on...). Make sure it visits all the squares and cleans the dirty ones. Is the orderly agent more efficient than the random one? |
