Naming Game
Implement the Naming Game as described in Chapter 5 of the Talking Heads book.
For meanings you can use either use categories as for example on the bottom of
page 125 or the agents could name eachother. The use of categories has the
advantage that you can easily experiment with the number of meanings, whereas
this is impossible when the agents have to name each other. For monitoring the
dynamics of the naming game you should implement both measures of communicative
success (p. 132) and lexical coherence (p. 134).
Additionally you should implement a monitor for tracing
the average number of word-meaning pairs each agent in the population knows. This
monitor should also be implemented as a running average.
After you have completed your implementation you should experiment with at
least two different parameters. Possible parameters include, but are not limited
to:
- number of agents in population
- number of meanings
- delta (increment/decrement of scores in lexicon)
- different lateral inhibition schemas (only hearer performs lateral inhibition)
Technical Requirements
Your implementation should be written in Common Lisp as it is defined in the
Hyperspec.
Write all your code in a single file and include some code at the bottom which
show how to run a series of language games.
Form
Write a small report (max. 5 pages) in which you describe the different
experiments you performed using the graphs created by your monitors. Send in your
report (preferably in .pdf) together with your final code to
Joris before the deadline.
The following criteria will be used to grade your work:
- do the agents reach communicative success?
- does lateral inhibition work as expected (meaning that there are no synonyms in
the resulting language of the agents)?
- is the code conform to a good programming style?
Deadline
15th of March
Guessing Game in Lisp
Extend your implementation of the previous assignment in such way that the
hearer is uncertain on which category is expressed by the speaker which will
give rise to homonyms.
The world of the agents is predefined and consists of objects which belong
to multiple categories. At the beginning of each interaction a subset of these
objects is choosen and presented to both speaker and hearer. This subset will
hereafter be called context. Implement a parameter which allows you to control
the complexity of the context (by which you control the maximum number of
discriminative categories for each object in the context; the lower this number
the less homonymy is expected). The minimum number of discriminative categories
for each object in the context should of course be one.
The interaction pattern can be summarized as follows:
| Speaker |
Hearer |
| chooses one object as topic t_s |
|
| finds discriminative category c_s for topic |
|
| finds word w for c_s |
|
| utters w |
hears w |
|
finds category c_h for word w |
|
tries to find unique object t_h using c_h |
| receives pointing information t_h |
points to interpreted topic t_h |
| points to intended topic t_s |
receives pointing information t_s |
| update association-scores |
update association-scores |
You can reuse the monitors of the previous assignment. After you have completed your
implementation you should experiment with the context complexity parameter.
Technical Requirements
Your implementation should be written in Common Lisp as it is defined in the
Hyperspec.
Write all your code in a single file and include some code at the bottom which
show how to run a series of language games.
Form
Write a small report (max. 5 pages) in which you describe the different
experiments you performed using the graphs created by your monitors. Send in your
report (preferably in .pdf) together with your final code to
Joris before the deadline.
The following criteria will be used to grade your work:
- do the agents reach communicative success?
- does lateral inhibition work as expected (meaning that there are no synonyms
and no homonyms in the resulting language of the agents or in other words that
the number of words is equal to the total number of categories in all
objects)?
- is the code conform to a good programming style?
Extended deadline
6th of April
Guessing Game in Lisp with True Ambiguity
In the previous experiment the agents could easily learn new forms by doing lazy learning by waiting for occasions in which there was no ambiguity in learning the correct category.
In order to make the Guessing Game more interesting and slightly more difficult you will have to extend your current implementation to be able to cope with contexts which have at least a complexity of two. The agents (and of course you as the experimenter) can use the assumption that each word should express exactly one category.
Another factor you should experiment with is the way the hearer handles a previously unknown word. A first approach would be to associate the new form to a randomly choosen discriminative category and standard lateral inhibition. A second approach would be to associate the new form with each possible discriminative category. In this approach you should also extend lateral inhibition in such way that it takes into account all possible categories that are associated with the topic.
For this assignment you have to compare both approaches to handling previously unknown words and the corresponding lateral inhibition schema. Generate a graph which shows both lexicon coherence and the average number of word-meaning pairs for both approaches.
Technical Requirements
Your implementation should be written in Common Lisp as it is defined in the
Hyperspec.
Write all your code in a single file and include some code at the bottom which
show how to run a series of language games.
Form
Write a small report (max. 5 pages) in which you describe the different
extensions you have made to your previous experiment to make it work in this set-up.
Send in your report (preferably in .pdf) together with your final code to
Joris before the deadline.
The following criteria will be used to grade your work:
- do the agents reach communicative success?
- does lateral inhibition work as expected (meaning that there are no synonyms
and no homonyms in the resulting language of the agents or in other words that
the number of words is equal to the total number of categories in all
objects)?
- is the code conform to a good programming style?
Deadline
27th of April
Multi-word Guessing game
In the previous assignments, the utterances the agents could produce and parse were
single word utterances. The goal of this assignment is to remove this restriction: the
agents are now allowed to use more than one word to express sufficient information to enable
the hearer to discriminate the topic. In this assignment we still use the assumption that the
topic consists of a single object.
The world you will have to use for this assignment consists of 10 chairs which each have 4
attributes: color, material, has-back and has-wheels. You can download an .arff file
here. Each context should consist of a variable number (4 seems to
work fine) chairs using random selection.
Conceptualisation (the selection of the attributes the agents need to express) needs to be
adapted. Instead of looking for the discriminative attributes (which often fails using the
restrictions imposed on the world of the agents), the conceptualizer needs to find a minimum
combinations of attributes which enables the agents to discriminate the topic from the other
objects in the context.
Suppose the context consists out of the following chairs:
| object |
color |
material |
has-back |
has-wheels |
| chair-3 |
red |
wood |
yes |
no |
| chair-4 |
black |
metal |
yes |
no |
| chair-5 |
red |
metal |
yes |
yes |
| chair-6 |
black |
metal |
no |
no |
A valid conceptualisation for chair-3 would be the single attribute wood as it is a
discriminative category for that chair. For chair-4 things would get slightly more
complicated as it has no discriminative categories. A combination of the attributes
black and has-back would be the only combination of two attributes that would
successfully discriminate the topic from the other elements in the context.
As the conceptualisation module is modified in a way that it might return more than one
attribute, the agents need a more sophisticated method for selecting the words they will use
in an utterance. They will need to first collect all words that cover a part or the whole of
the meaning and they need a way of combining these words in order cover the complete meaning.
As there might be many of such combinations you will need a selection procedure which selects
the best combination known to the speaker. The same goes for interpretation, but in
interpretation you can also cut away the combinations that do not lead to a single object
in the context (using the assumption discussed above).
After a successfull game all rules used in this interaction are rewarded. All conflicting
rules (covering the same meanings for the speaker or entries that associate one of the words
in utterances for the hearer) are punished by lateral inhibition.
The main learning operator for the speaker is that it invents a new form covering all
attributes it didn't have a word for. The main learning operator for the hearer is to learn
the association between an unknown word and the meaning it thinks it might cover. For deducing
this meaning it first needs to run conceptualisation, only maintaining those conceptualisations
that are compatible with the meaning it could interpret, and finally taking the difference
between the conceptualised meaning and the meaning it could interpret. The third and final
learning operator should be used when the hearer misinterpreted a single word utterance.
In this case the hearer first conceptualises the topic and then associates each possible
conceptualisation to the single word in the utterance.
When your set-up is completed you could experiment by changing the number of chairs
in the context. What seems to be the ideal context size and can you explain why?
Technical Requirements
Your implementation should be written in Common Lisp as it is defined in the
Hyperspec.
Write all your code in a single file and include some code at the bottom which
show how to run a series of language games.
Form
Prepare a presentation in which you show the results of this experiment. You also have
to write a small report (max. 5 pages) in which you describe the different extensions
you wrote and the different problems you encountered. You sould also include some results
on changing the context size and try to find a possible explanation for this. Send in your
report (preferably in .pdf) together with your final code to
Joris before the deadline.
Reference
Chapter 4 of the of
Joris Van Looveren's PhD thesis.
Deadline
25th of May, 11am
