From: popx@vax.oxford.ac.uk
Newsgroups: sci.cognitive
Subject: AI teaching kit/competition
Date: 12 Dec 92 18:10:56 GMT
Organization: Oxford University VAX 6620

I have posted this to comp.ai, comp.lang.pop, and comp.lang.prolog.
People on sci.cognitive might also be interested, either for teaching,
or to take part in the competition.

Jocelyn



    ANNOUNCING THE EDEN/POPBEAST AI COMPETITION AND TEACHING KIT


Do you want to take part in Oxford University's international AI-in-Eden
competition? Do you have a Poplog system?(*) Are you looking for AI
teaching materials? If so, read on!

We have developed Eden as a Poplog-based AI microworld(**) in which
members can experiment with learning and planning, and we are now making
it available as part of an international AI competition. Unlike many
leading brands of microworld, Eden puts the emphasis on learning, whilst
still providing a rewarding environment where the less creative
rule-based AI need not feel out of place.

(*) Or the willingness to translate some Pop-11 simulation code to your
favourite programming language.

(**) Hopefully to be accepted as the official ANSI standard microworld.


Contents
--------

Eden
The importance of learning
The competition
Eden for teaching
Eden and Prolog       
How to obtain Eden
The Oxford University AI Society


Eden
----

Eden is a two-dimensional microworld written in Pop-11. You can use it
as a setting for AI programs by writing procedures to control a ``Bug''
which lives within it. These procedures form Bug's brain; they have
access to its perceptions, and can use any AI techniques you want ---
genetic algorithms, neural nets, rule-based systems --- in arriving at
sensible actions which will keep Bug alive and fed. The present version
of Eden is fitted with an interface to Prolog, so you can write your
brain in either language. In addition, the Poplog features for
mixed-language programming allow you to call Lisp and ML.

Eden consists of a grid of cells, each of which can contain objects such
as keys, doors, boulders and quicksand. Bug's objective is to find and
eat a piece of food which the simulator has placed somewhere within this
grid. To do this, Bug must negotiate its way towards the food while
dealing intelligently with obstacles. Eden's laws of physics allow Bug
to take one of several different actions when it encounters an object.
The simulator then works out the consequences of the chosen action on
Bug and on Eden, and displays these graphically in a Ved window. Bug's
perceptions are updated to reflect the new state of the world, and the
cycle repeats. It's important to choose the actions with care! If you
stop to use a key on a door, you'll open it; but if you stop on a
quicksand, you'll merely drown.

To implement a Bug brain, you must write a procedure which accesses
Bug's perceptions, via procedures built into Eden, and which returns an
action as its result. Poplog users can do this in Pop-11 or any of the
other Poplog languages; or of course you can translate the Eden
simulator into your favourite programming language. Full documentation
is given as a guide to doing so.


The importance of learning
--------------------------

Eden is different from many microworlds in that Bug dies as soon as it
has eaten the first piece of food. It may also succumb to various
objects such as quicksands --- and, as we said above, it dies when it
runs out of energy.

This is less severe than it sounds. After each death, the simulator puts
Bug back into its original starting position, resets the rest of the
world to its starting state, calls a user-written routine named
``bugdead'', and resets Bug's energy to its initial value. However,
Bug's brain is unaffected by the process, and so when it dies, Bug does
not forget anything it has already learned. This makes death more like
the ``go back to start'' square in a board game.

This structure of linked reincarnations allows bugs to learn by trial
and error. During one lifetime, Bug can build up whatever data
structures it wants. Production-system bugs might learn new IF-THEN
rules or amend their old ones; neural-net bugs might change their
synaptic strengths; genetic-algorithm bugs might evolve towards a new
population of genes. Because brains are unaffected by death, the
learning process can be taken as far as you want just by repeating
training runs. When Bug dies, the simulator calls ``bugdead''. You write
this; after each run, it decides whether to reincarnate in the same
world, move to a new one, or stop altogether.

This indicates the main reason for death. It imposes a time limit on
Bug's finding the food, and gives it another chance to solve the world
should it get itself trapped.

How much learning you make Bug do is up to you. You could program in
some a priori knowledge about the properties of objects, and just let it
learn how to survive, given this knowledge. You could even try to
program correct behaviour patterns, so that it is more-or-less
instinct-driven. If you do this, you will probably find yourself using
classical ``symbolic'' AI techniques, writing planners, expert systems,
and so on. Alternatively, you could render Bug as helpless as a new born
baby and insist that it learn about the objects themselves by trial and
error: that it learn that keys open doors but not boulders, that you can
pick up a key but not a door, and so on. If you try this, you will
probably end up writing a neural net or a genetic algorithm.


The competition
---------------

You can use Eden for your own experiments, or for teaching, ... or you
can enter your bug in our competition. This consists of three stages. In
the first stage, you are supplied with a set of extremely simple
microworlds, each containing a single object or pair of linked objects
such as doors and keys. These are the training worlds. You can run your
Bug through them as many times as you like, with the objective of
teaching it the properties of these basic objects, and using its brain
in the next stage. There are also some more advanced training worlds,
similar but not identical to those to be used in the competition. They
contain more difficult problems, such as having to get from one room to
another by using a key and hammer to pass through intervening doors and
rocks. In addition, you can create your own worlds.

To enter the competition, you must send us the source code of your brain
procedure. This should be in Poplog V14-compatible Pop-11, Prolog, ML,  
or Lisp: we cannot guarantee to provide compilers for other languages.
In the second stage, the beginning of the competition proper, we will
put this source onto our machine and run it on a series of competition
worlds containing one or more of the basic objects in combination. For
example, you may have to open a chest to get the key to a door that
shields the food.

The idea then is that we will take your Bug which you have trained, and
put it into the first competition world. When it dies, either through
eating the food, running out of energy, or being killed by a fatal
object, it can elect either to stay in the same world and have another
go, or to pass on to the next one in the series.

The reason for allowing Bug to return to the same world is to allow it
some more training time. However, such time carries a penalty. Bug's
ranking in each world is determined by the total amount of energy left
at the end of each life, divided by the number of lives. Thus, if you
fail to find the food and, sadder but wiser, decide to try again, you
will lose some points for the time spent in the first life. So stage two
definitely rewards bugs that are well-trained in advance. The final
section of this file described the scoring in more detail.

Since learning is one of the most difficult problems in AI, we will
accept bugs whose behaviour has been entirely pre-programmed, perhaps in
a rule-based system. The competition documentation supplied with Eden
describes the properties of all the objects encountered during stage
two. Together with the training worlds, these will give you all the
information you need to write such a Bug. Since this kind of Bug would
gain no benefit from being reincarnated in a competition world that had
just killed it, it will probably elect to proceed to the next world
after each death. We hope this arrangement will allow both novices and
experienced AI-ers to take part.                       

Stage three of the competition is harder, and puts the emphasis on
learning. This time, we will run your Bug through a sequence of worlds
where new types of object will exist that it will not have encountered
before. It will have to learn their properties by experiment, and then
use or avoid them as it makes for the food. This final stage hopes to
separate genuinely ``intelligent'' Bugs from the others.

The competition is open to anyone, whether undergraduate or experienced
AI rsearcher. The closing date for entries is May 1st 1993. Though we
can not afford to provide monetary prizes, there is some publicity to be
gained. We will select those entries which we deem to be the most
successful, and also the most interesting, and write them up in the next
issue of the Poplog Newsletter. We will also add them, together with any
improvements the authors care to make after the competition, to the Eden
FTP archive.


Eden for teaching
-----------------

Eden is also intended as a light-hearted setting in which to teach AI.
To illustrate how, it comes with a trial version of Jocelyn Paine's
PopBeast. This is a simple sub-Shrdlu Prolog bug which can read and
parse simple commands, extract their meaning, plan how to satisfy these
commands, and then carry out the plans. PopBeast comes with a set of
draft tutorial notes in Latex format. It is still rudimentary, and
improvements are welcome. We'd like to have your comments on using
PopBeast for teaching, and we'd also appreciate any improvements in the
way of planners, parsers, and such. These will all be put into the
public domain.


Eden and Prolog
---------------

To avoid confusing non-Poplog users, we should add that Eden relies on
Pop-11, both to run the simulator, and for PopBeast to represent its map
of the world. These involve extensive array-handling, and would probably
be inefficient to translate into Prolog (there's a challenge for purists
... :-). However, they should go quite well in C.

PopBeast's planner and parser are written in Prolog, and are largely
independent of the underlying Pop-11. We hope they will be of interest
to those using other Prolog implementations.


How to obtain Eden
------------------

Eden is available by anonymous FTP from the Imperial College archive.
The archive's FTP address is
    src.doc.ic.ac.uk

The equivalent numerical address is
    146.169.2.1

You access this archive in the normal way. Give your login name as
    anonymous
and use your Email address for the password. If, having logged in, you
find that your system can't cope with the messages from the FTP (one
symptom of this may be that when you do an 'ls', you get the message
'can't build data connection'; another may be system responses not
arriving until after the following command), then log out, and log in
again, with - as the first character of the password. This trick applies
to most FTP systems, by the way.

Eden is stored in the directory:
        computing/programming/languages/prolog/pd-software
with a short-cut entry of:
        packages/prolog-pd-software
I.e., to access it, 'cd' to either of the above. Note: Eden is not
restricted to Prolog users. However, we consider that it contains enough
Prolog code, in the form of PopBeast, to justify its inclusion in this
directory.

NOTE: If you can't find Eden in the above directory, it is because I'm
still waiting for it to be copied across by the archive maintainer. In
that case, there should be a copy in the top-level directory /tmp. It's
worth checking this directory first in any case, because if I update
Eden, the newest version will be in there.

Eden itself is in the file
    eden.tar.Z
It is in compressed TAR format, so once you have fetched it, uncompress
it, and then de-tar the result. Users of Unix systems should have no
problem with this, since tar and uncompress are standard utilities.
Those using other systems may not be so lucky, though they are now
available for VMS and MS-DOS at least. I believe the archive also allows
the file to be uncompressed before it's sent: check the site
documentation.

De-taring the uncompressed file will recreate the original directory
tree. The top-level directory contains a plain text file called README.
This gives you information on installing Eden. This is not difficult,
and is mainly a matter of hooking it into the Poplog library system.
Eden comes with numerous HELP files describing it, the competition,
and various useful Bug-control routines.


The Oxford University AI Society
--------------------------------

Eden and the competition were developed by Simon Perkins, Jocelyn Paine
and Edmund Chattoe of the Oxford University Artificial Intelligence
Society. We would like to hear from other societies, and from people who
would be willing to talk at our meetings, and also to receive new
members. If you are near to Oxford and would like to know more about our
activities, we can add your Email address to our distribution list. You
will then automatically be sent news of all our talks and other
meetings.


Jocelyn Paine (POPX@VAX.OXFORD.AC.UK)
Edmund Chattoe (ECONEC@VAX.OXFORD.AC.UK)
Simon Perkins (now at Edinburgh University AI Department)
Newsgroups: sci.cognitive