6CCS3ML1 (Machine Learning)

Agents .py

(b)  The ClassifierAgent class provides some simple data handling.  It reads data from a file called good-moves .txt and turns it into arrays target and data which are similar to the ones you have used with scikit-learn. When we test your code, it will have to be able to read data in the same format as good-moves.txt, from a file called good-moves .txt.  If it doesn’t, we will mark your code as not working.  So make life easy for yourself and stick to the (admittedly, but intentionally, limited) data format that we have provided.

To run the code in classifierAgents .py, you use:

python3  pacman.py  --pacman  ClassifierAgent

Note the difference in capitalisation between file name and class name.

Now open your editor and take a look at the code for ClassifierAgent. There are six functions in it:

(a) init ()

The constructor.  Run when an instance of the class is created.  Because the game doesn’t exist at this point, it is of limited use.

(b)  loadData()

This is a simple utility. The data in good-moves .txt is stored as a string. We need it as an array of integers. This does the conversion.

(c) registerInitialState()

This function gets run once the game has started up.  Unlike init() , because the game has started, there is game state information available.  Thus it is possible for Pacman to  “look” at the world around it.

Right now this is the only function that is doing any real work.  It opens the file good-moves .txt, and extracts the data from it, where data is parsed into the arrays data and target.  These ar-   rays are accessible from any function.  (They are data members of the class ClassifierAgent.)

(d)  final()

This function is run at the end of a game, when Pacman has either won or lost. (e)  convertNumberToMove()

Another simple utility.  The data  in good-moves .txt encodes  moves that Pacman made in the past using integers. What you need to do is to produce moves of the form:

Directions .NORTH

since that is the format which the game engine requires.  This function converts from one to the other in a way that respects the original conversion from moves to integers.

(f) getAction()

This function is called by the game engine every time step.  What it returns controls what Pacman does.  Right now it just returns Directions.EAST or a random move (see predict() in classifier.py). (The function also does some other stuff, but we will get to that later).

3    What you have to do (and what you aren’t allowed to do)

3.1 Write some code

Your task in this coursework is to write a classifier using classifier.py which uses the data in good-moves .txt to control Pacman.  By  “control Pacman” we mean  “select an action and return it in the function getAction (the code is already set up for you this way).  However, because this is a module on machine learning, not a module on game programming, we are quite prescriptive about how you go about doing this:

(a) Your code is only allowed limited access to information about the state of the game.  What you are allowed to access is the information provided by:

api.getFeatureVector(state)

This returns a feature vector in the form of an array of 1s and 0s like this:

[1,  0,  1,  0,  0,  1,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]

This records details of whether there are walls, food, and ghosts in the squares around Pacman. You don’t  need to  know  what  each  number  means  (though  if  you  want to  know,  look  in api.py).  What you do  need to know is that if your code uses any other information about the game to decide what to do, you won’t get any marks for the coursework.

(b) Your code should use a classifier to make a decision, based on the information in features, to decide what to do. Thus the classifier should be trained using the information in self .data and self .target, and should predict an action when passed the data in features (again, this is already set up).

(c)  You are allowed to use a classifier from an external library such as scikit-learn.  However, if you use a classifier from an external library, you will not get as many marks as if you write a classifier yourself.  (For details on exactly how we will mark your code, see the marksheet on KEATS. Also ensure you read the coursework’s FAQs on KEATS.)

(d)  If you do code your own classifier,  it does not have to be complicated.  It could  be as simple as a 1-nearest neighbour classifier.  However, the more sophisticated the classifier, the more marks you will get.  (Again, for details you should see the marksheet and FAQs on KEATS.)

(e)  To get full marks, your code has to run until either Pacman wins a game, or until Pacman gets eaten by a ghost (and loses a game).  In other words, your code should not crash or otherwise fail while we are running it.  Losing a game is not failing.  In fact, from the point of view of marking, we don’t care if your Pacman wins, loses, gets a high score or a low score.  We only care that your code successfully uses a classifier to decide what to do.

3.2 Things to know

If you look in good-moves .txt, you will see that each line contains a feature vector like the one above, plus a final digit.  (There are no brackets or commas, that is because good-moves .txt holds strings not arrays.) The first digits are indeed a feature vector, and the last digit encodes an action. When the data is read in by registerInitialState, the feature vector part is loaded into data, and the “action” is loaded into target such that the ith elements of data and target go together. The data was collected from code that played Pacman.  (Indeed, from some code that won games of Pacman.) At each step, the feature vector and move were stored in good-moves .txt. And that is exactly why you can create a classifier from it.  If you train a classifier on the good-moves data, then that classifier should be able to predict a sensible move given a new feature vector.

Note that while the good-moves data is what we will test your code with (or rather it is one of the things we will test your code with), you may want to create some custom training data.  To make that easy, we have provided TraceAgent (in the file traceagents.py).  If you run this using:

python3  pacman.py  --p  TraceAgent

you will get the same keyboard controlled Pacman as you saw before, BUT one which outputs data on your move and the corresponding feature vector.  This data is written to moves .txt.  (If a file already exists with that name, it is over-written, so be careful.)

3.3 Limitations

There are some limitations on what you can submit.

(a) Your code should be in Python 3.

Code written in a language other than that will not be marked.

Code written in Python 2 is unlikely to run with the clean copy of pacman-cw1 that we will test it against.  If it doesn’t run, you will lose marks.

The reason for this is that we do not have the resources to deal with code written in multiple languages, and to ensure that we can run code written in Python 2.

(b)  Your code will be tested in the same environment as we have been using in the lab.  That is the standard Anaconda Python 3 distribution, with scikit-learn also installed (and the scikit-learn distribution includes numpy).  Code using libraries that are not in this collection may not run when we test it.  If you choose to  use such libraries and your code does not run when we test it, you will lose marks.

The reason for this is that we do not have the resources to deal with setting up arbitrarily complex  environments  (with  the  possibility  of  libraries  with  arcane  interactions)  for every submission.

(c) Your code must only interact with the Pacman environment by making calls through the version of api .py supplied in pacman-cw1 .zip.  Code that finds other ways to access information about the environment will lose marks.

The idea here is to have everyone solve the same task.

(d) You are not allowed to modify any of the files in pacman-cw1 .zip except classifier.py.

Similar to the previous point, the idea is that everyone solves the same problem — you can’t change the problem by modifying the base code that runs the  Pacman environment.  Also, your code will have to run against a clean version of the code in pacman-cw1 so you’ll just be making trouble for yourself.

(e) You are not allowed to copy, without credit, code that you might get from other students or find lying around on the Internet.  (This includes the use of code that was distributed as part of the module — if you use code from files other than classifier.py and classifierAgent .py without attribution, we will consider that to be plagiarism.) We will be checking.

This is the usual plagiarism statement. When you submit work to be marked, you should only seek to get credit for work you have done yourself.  When the work you are submitting is code, you can use code that other people wrote, but you have to say clearly that the other person wrote it — you do that by putting in a comment that says who wrote it.  That way we can adjust your mark to take account of the work that you didn’t do.  Please add any citations, descriptions, or whatever you want us to know in the python file.

Please also ensure you familiarise yourselves with what constitutes  plagiarism and collusion and how to avoid them (ensure you read the information on KEATS); e.g. copying large parts of code from others, even with attribution, is not allowed. We need to be able to assess your OWN contribution.

(f) Your code must be based on using a classifier on the data in good-moves .txt.  If you don’t submit a program that contains a recognisable classifier, you will lose marks.

4 What you have to hand in

Your submission should consist of a single ZIP file.   (KEATS will be configured to only accept a single file.) This ZIP file must include a single Python file (your code):  classifier.py.

The ZIP file must be named:

cw1-- .zip

Remember that we are going to evaluate your code by running your code by using variations on python3  pacman.py  -p  ClassifierAgent

and we will do this in a vanilla copy of the pacman-cw1 folder, so the base class for your agent must be called ClassifierAgent and use class Classifier and the skeleton provided.

To streamline the marking of the coursework, you must put all your code in one file, and this file must be called classifier.py (which we provide).

Do not just include the whole pacman-cw1 folder.  You should only include the one file that includes the code you have written.  Do not modify any of the other files either when developing your code.

Submissions that do not follow these instructions will lose marks.

5    How your work will be marked

There will be three main components of the mark for your work:

(a)  Functionality

We will test your code in classifier.py by running the classifierAgents .py file against a clean copy of pacman-cw1.

As discussed above, for full  marks for functionality,  your code  is  required  to  run  when we invoke the command: