simlang_4_lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulating Language 4, Modelling signalling systems (lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*This is a first draft of lecture notes for the Simulating Language course. It probably contains lots of typos!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Starting simple: signalling\n",
    "\n",
    "In this course, our aim is to build a series of models that allows us to explain why language is the way it is by exploring how it came to be that way. We will be building models that bridge the individual and population levels of description and integrate different timespans from milliseconds to millenia. But before we get to the particular structural properties of language - the so-called *design features* with which you might be familiar - we're going to start out with something much more evolutionarily ancient and, arguably, simpler: innate signalling.\n",
    "\n",
    "This is the kind of communication we see in many species from bacteria to primates. The most celebrated example of this kind of signalling is given by the alarm calls of the vervet monkey, as explained by Robert Seyfarth in this [video clip](http://www.youtube.com/embed/3lsF83rHKFc). What [Seyfarth, Cheney, & Marler (1980)](http://science.sciencemag.org/content/210/4471/801) have shown is that vervet monekys produce distinct vocalisations in response to different predators. When they do so, other vervets who hear these alarm calls respond in an appropriate way, even if the predator isn't present. (They show this using some clever playback experiments with hidden loudspeakers. The monkeys run into trees when they hear the leopard alarm, look up into the sky when they hear the eagle call, and search the ground when they hear the vocalisation specific to snakes. \n",
    "\n",
    "Of course, this is only one example of a signalling system - have a look at the excellent [Skyrms (2010)](https://books.google.co.uk/books/about/Signals.html?id=pGwVDAAAQBAJ&printsec=frontcover&source=kp_read_button&redir_esc=y) for more elaborate examples, although note that his approach to modelling them is slightly different from the one we'll take here.\n",
    "\n",
    "### Sender-receiver games\n",
    "\n",
    "We can think of what is happening in this type of communication as a kind of two-player game. The world is in some state that only one player knows about (we'll call that player the sender). The sender wants the other player (the receiver) to act in a certain way that is appropriate to the state of the world. How do they acheive this? They need to produce some signal and hope that the receiver can use this to act in the right way.\n",
    "\n",
    "To do this, the sender has a strategy for playing the game such that for every state of the world, they will have some signal to send. For example, in state 1 of the world, they produce signal a, in state 2 of the world, they produce signal b.\n",
    "\n",
    "This isn't enough, however. The receiver also has to have a strategy for playing the game. That strategy must specify and action for each signal received. For example, if they observe signal a, they carry out action 1, if they observer signal b, they carry out action 2.\n",
    "\n",
    "![img](img/Game1.jpeg)\n",
    "\n",
    "How do we know if this game is successful? It depends which action is appropriate for which state of the world. In the example above, let's assume that action 1 is a good response to state 1, and action 2 is a good response to state 2. In this case, then this pair of strategies on the part of the signaller and receiver are good ones. If on the other hand, the sender strategy were altered so that signal a were to be produced for state 2, and signal b produced for state 1, then the pair of strategies would not work.\n",
    "\n",
    "\n",
    "The vervet system involves three states in the world: the presence of an eagle, the presence of a snake, and the presence of a leopard. It involves three appropriate actions: searching the skies, searching the ground, and running up a tree respectively. The vervet sender produces a *grunt*, a *chuttering* sound, and a *bark* for eagles, snakes and leopards (in that order). Crucially, the receiver responds appropriately to each of these three vocalisations.\n",
    "\n",
    "This is what makes the vervet monkey system successful. It's the way the sending strategy and the receiving strategy are \"lined up\" rather than any specific features of the vocalisations themselves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What's missing from this as a model of language?\n",
    "\n",
    "I just want to pause here and reflect on the simplicity of the model we're heading towards. We're imagining that we can abstract away from the details of communication (the specifics of vocalisations, the specifics of the states of the world etc. etc.) and just look at the strategies for *mapping* states of the world onto vocalisations on the one hand, and vocalisations onto actions on the other.\n",
    "\n",
    "This seems a very long way from the richness of human language. It is - but we'll get there! It's worth reflecting specifically on what the differences between this kind of communication and linguistic communication are. \n",
    "\n",
    "Firstly, there is no internal structure to the signals or the \"meanings\" in this model. In fact, there's not really any direct analog of meaning, because we've been dividing up the states of the world and the appropriate actions. However, we can imagine some kind of internal state that generalises between the visual appearance of leopards and running away from leopards in the mind of the vervet. Nevertheless, there's nothing important about the sequence of sound made by a chuttering vervet or the fact that both leopards and eagles are warm blooded that structures the signalling system of a vervet. All that matters is that there are three completely distinct signals, and three completely distinct \"meanings\".\n",
    "\n",
    "This couldn't be more different for language. Language is characterised above all else by leveraging systematic patterns *within* signals and how they relate to systematic patterns *within* meanings. Just look at the text you're reading. You're able to understand it (I hope!) because you know it is made up of meaningful parts that combine in intricate ways to create larger meaningful wholes. This also allows language to be *productive* by enabling us to create entirely novel, yet understandable sentences.\n",
    "\n",
    "Secondly (and, as we'll see in this course, relatedly), the vervet monkey signalling system is essentially *innate*. In other words, the specific mapping of chuttering with snakes and so on, is universal for the vervets. You don't find different vervet communities with the same alarm calls but mapped out in different ways. (Note, this doesn't mean that the vervet system pops out perfectly formed at birth. Like many features of an organism's anatomy it develops over time. Infant vervets will produce the eagle call for a variety of birds early on for example.)\n",
    "\n",
    "This is in stark contrast to language. The English utterance \"Snake!\" is in no sense part of my genetic inheritance. There's nothing inevitable about it, any more than the Basque utterance \"Arrano!\".\n",
    "\n",
    "Now, you may know that there is a long running debate about innateness in linguistics, and we'll wade into that debate armed with simulations later in this course, but everyone agrees that whatever is innate about human language, it isn't the actual mapping between signals and meanings.\n",
    "\n",
    "We'll set aside for now human language, and return to the kind of innate communication that is so rife in nature, but keep in mind that the questions we're going to be asking are likely to end up being relevant to language later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two questions about the evolution of communication\n",
    "\n",
    "Before we build a model of innate signalling it's important that we figure out what we might want that model to help us understand. Here are two good questions we should be asking:\n",
    "\n",
    "- How are communicative conventions established?\n",
    "\n",
    "- What ensures those conventions are communicatively useful?\n",
    "\n",
    "We're going to take \"convention\" here in a very broad sense - perhaps broader than it is usually defined. Roughly speaking, we're going to take a convention to be a system of behaviour that is **shared among members of a population**. In these terms, the vervet monkey system counts. The population all produce the same vocalisations for a particular predator, and all respond in the same way to hearing that vocalisation.\n",
    "\n",
    "So, we want to know both where these conventions come from, and how they end up being useful.\n",
    "\n",
    "It's important to note that there is no guarantee that a signalling system ends up being shared. For example, you could certainly *imagine* a population of vervets where not everyone produced the same vocalisations, nor responded in the same way. The fact that this isn't what the vervet system looks like is therefore something we need to explain.\n",
    "\n",
    "Furthermore, we need to understand the ways in which conventions may or may not be useful. Let's break this down a bit.\n",
    "\n",
    "### Communication, homonymy, synonymy\n",
    "\n",
    "**Homonymy** is when we have multiple states (or acts) that map on to a single signal.\n",
    "\n",
    "![img](img/Homonymy.jpeg)\n",
    "\n",
    "**Synonymy** is when we have a state (or act) that maps to multiple signals.\n",
    "\n",
    "![img](img/Synonymy.jpeg)\n",
    "\n",
    "Which of these determines the communicative functionality of a signalling system (in addition to conventionality)? It is tempting to think that a good communication system should avoid both synonymy and homonymy, but actually, it's only really homonymy that is detrimental to communication. If a vervet monkey were to produce the same vocalisation for both snakes and eagles, for example, then the other vervets would not know whether to look up or down. If a vervet monkey used a variety of different vocalisations for snakes, then that's not really a problem as long as the other vervets knew to search the ground for any of them.\n",
    "\n",
    "Curiously, when we look at the lexicon of natural languages, however, we typically find that homonymy is very common and true synonymy extremely rare. This is a puzzle we have to set aside for now and return to later in the course when we consider the different ways in which innate versus learned conventions are established."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Our first model!\n",
    "\n",
    "Now we have some questions we want to answer (about the origins of conventionality in a signalling system, and how these systems end up being communicatively useful), it's time to build our first model.\n",
    "\n",
    "First, we're going to make things a little easier and remove the distinction between states and actions. Instead, we're going to follow the suggestion I made earlier that there is an underlying level at which these can both be considered aspects of the same *meaning*. In other words, seeing a leopard and running away from a leopard are both aspects of the meaning \"leopard\".\n",
    "\n",
    "So, our sender maps from meanings to signals, and our receiver maps from signals back to (hopefully) the same meanings.\n",
    "\n",
    "Simulated models of individuals are known as *agents*, and our first step in building a model of innate signalling is to build an agent that can both act as a receiver and a signaller.\n",
    "\n",
    "We need some way to represent the mapping between meanings and signals. There are lots of entirely reasonable ways of doing this, but we're going to represent the mapping as a matrix of associations. (A matrix is simply a mathematical term for a table of numbers.)\n",
    "\n",
    "Actually, we're going to need two matrices: one for the production behaviour of the sender, and one for reception behaviour of the receiver. The production matrix is going to be a table of numbers where each *row* is a different meaning, and each *column* is a different signal. The reception matrix on the other hand has each row being a signal and each column being a meaning.\n",
    "\n",
    "For example, here's a production matrix for three meanings $(m_1, m_2, m_3)$ and three signals $(s_1, s_2, s_3)$:\n",
    "\n",
    "|.    |$s_1$|$s_2$|$s_3$|\n",
    "|-----|-----|-----|-----|\n",
    "|$m_1$|1    |2    |0    |\n",
    "|$m_2$|0    |1    |1    |\n",
    "|$m_3$|0    |3    |4    |\n",
    "\n",
    "The idea is that the numbers in these cells, although somewhat arbitrary, encode the strength of association between the meaning and signal. How do we take a matrix like this and get it to actually **produce** signals? One way is referred to as *winner take all*. We simply look along the row for the meaning we wish to produce and pick the signal with the highest association strength. For example, $m_3$ is produced using $s_3$. (Where there is a tie, like for $m_2$, we pick among the winners at random.)\n",
    "\n",
    "Similarly, we can use winner take all to **receive** signals.\n",
    "\n",
    "|.    |$m_1$|$m_2$|$m_3$|\n",
    "|-----|-----|-----|-----|\n",
    "|$s_1$|1    |0    |0    |\n",
    "|$s_2$|2    |1    |3    |\n",
    "|$s_3$|0    |1    |4    |\n",
    "\n",
    "For a particular signal in this matrix, we look along the rows and find the meaning with the highest association strength. Here, $s_3$ is understood to mean $m_3$.\n",
    "\n",
    "That completes our model of signalling!\n",
    "\n",
    "### Measuring communicative success\n",
    "\n",
    "Now we have a model of signalling, we might want to be able to measure how good a signalling system is for communication. For example, how successful would a pair of vervets be if one was sending signals and the other receiving signals using the two matrices above? \n",
    "\n",
    "One measure - called *communicative accuracy* is on average how often the pair will communicate successfully. In other words what percentage of the time will the receiver understand the same meaning that the sender was prompted to produce by the world? It's worth pausing for a moment and trying to work this out on a piece of paper...\n",
    "\n",
    "... If you had a go at working it out, you might have tried each meaning in turn, figured out what signal or signals would be produced, and then figured out what meaning or meanings would be understood by the receiver given those signals, and how often (if ever) they would be understood to mean the original meaning and then averaged that for each meaning. (Or something like that!)\n",
    "\n",
    "This is actually a pretty reasonable way of working it out. There are even ways of expressing what you're doing there using a branch of mathematics called linear algebra.\n",
    "\n",
    "But we're going to take a different approach, that although long-winded, will pay off in the long run. We're going to run a simulation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating communication\n",
    "\n",
    "We're going to use a technique called *Monte Carlo simulation* to very explicitly model what we're trying to capture: the communicative success of two agents. This involves building a simulation of thousands of communication events between a sender and a receiver. The \"recipe\" (or *algorithm*) for such a simulation is as follows.\n",
    "\n",
    "For a particular sender and receiver do the following:\n",
    "1. Pick a random meaning\n",
    "2. Use winner take all to generate a signal for that meaning according to the sender's production matrix\n",
    "3. Use winner take all again to see what meaning corresponds to that signal in the receivers's reception matrix\n",
    "4. If the receiver's meaning is the same as the orignal one, count as success.\n",
    "5. Repeat steps 1-4 thousands of times and return the proportion of these \"trials\" that were successful. This is your *communicative accuracy score*. \n",
    "\n",
    "If we do this for the two matrices given above, we get a communicative accuracy of approximately one third. (Note that this is approximate because it depends on the number of trials, and how the random picking of meanings and the random picking of signals and meanings for ties in the winner take all step work out. This random variation in the results is actually a nice property of monte carlo simulations because it's exactly the degree of variability you'd expect to see in the real world. Sometimes a signalling system is going to look better (or worse) than it is because of good (or bad) luck!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How do we actually build all this in Python?\n",
    "\n",
    "We're going to see how to build this in Python in the next lab, but for a first step, let's see how we might model matrices with the simple subset of Python we're using in this course. One reasonable way is to treat a matrix as a list of lists. So, for example, the production matrix above would be represented as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "production_matrix = [[1, 2, 0], [0, 1, 1], [0, 3, 4]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the set of assocation strengths for $m_1$ by pulling out that item from the matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 0]\n"
     ]
    }
   ],
   "source": [
    "print(production_matrix[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we use the index `0` because Python counts from zero. \n",
    "\n",
    "If we wanted to get the strength of association betwen $m_2$ and $s_1$, we first need to get the row for the meaning out, and then get the cell from that row. We can do this in two steps like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "m2_associations = production_matrix[1]\n",
    "print(m2_associations[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we can get at this more easily in one step like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(production_matrix[1][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These simple steps will help us build the full model of communication (including the winner take all algorithm, and the monte carlo simulation) in the lab. We'll use the code we build in the next lab and develop further in the next lecture to answer the following questions, which are worth pondering in the abstract already:\n",
    "\n",
    " - Some signalling systems are better than others. How do animals end up with the best ones?\n",
    " - What about signalling between two agesnt with *different* matrices of associations? Could there be different scores for sending versus receiving?\n",
    " - What about whole *populations* of agents, each with different signalling systems?\n",
    " \n",
    "That's where we'll be headed next."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}