simlang_5_lab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulating Language 5, Simple Innate Signalling (lab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below builds up to a function, ```ca_monte```, which measures and returns the level of communicative accuracy between a production system and a reception system. Signalling systems are stored as lists of lists of association weights. This list of lists structure can be thought of as a matrix with meanings on the rows and signals on the columns (for production matrices) or signals on the rows and meanings on the columns (for reception matrices).\n",
    "\n",
    "You should go through this notebook cell by cell, running each cell by using SHIFT+ENTER."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we import the random library and the usual plotting stuff."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import set_matplotlib_formats\n",
    "set_matplotlib_formats('svg', 'pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now here's the bulk of the code, in three functions, ```wta``` (for \"winner take all\"), ```communicate```, and ```ca_monte```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wta(items):\n",
    "    maxweight = max(items)\n",
    "    candidates = []\n",
    "    for i in range(len(items)):\n",
    "        if items[i] == maxweight:\n",
    "            candidates.append(i)\n",
    "    return random.choice(candidates)\n",
    "\n",
    "def communicate(speaker_system, hearer_system, meaning):\n",
    "    speaker_signal = wta(speaker_system[meaning])\n",
    "    hearer_meaning = wta(hearer_system[speaker_signal])\n",
    "    if meaning == hearer_meaning:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def ca_monte(speaker_system, hearer_system, trials):\n",
    "    total = 0.\n",
    "    accumulator = []\n",
    "    for n in range(trials):\n",
    "        total += communicate(speaker_system, hearer_system, \n",
    "                            random.randrange(len(speaker_system)))\n",
    "        accumulator.append(total / (n + 1))\n",
    "    return accumulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll try and understand what this code does and why in a minute, but for now let's try getting it to do something. Let's say we had three meanings, and three signals. Let's imagine a speaker who used signal 0 for meaning 0, signal 1 for meaning 1, and both signal 1 and 2 for meaning 2, and a hearer who understood meaning 0 for signal 0, meaning 1 or 2 for signal 1, and meaning 2 for signal 2. What do we expect the communicative accuracy to be for these two individuals?\n",
    "\n",
    "Try and figure this out in your head first (it might help to write out the matrices on a piece of paper).\n",
    "\n",
    "Now, let's simulate it! Enter the following code in the next cell (note I've formatted the list of lists nicely so you can read them as matrices, but these can also be entered all on one line if you want):\n",
    "\n",
    "```python\n",
    "speaker = [[1, 0, 0],\n",
    "           [0, 1, 0],\n",
    "           [0, 1, 1]]\n",
    "\n",
    "hearer = [[1, 0, 0],\n",
    "          [0, 1, 1],\n",
    "          [0, 0, 1]]\n",
    "\n",
    "ca_monte(speaker, hearer, 100)\n",
    "```\n",
    "\n",
    "This simulates 100 interactions between the speaker and hearer and returns a list consisting of the average communicative accuracy so far at each interaction (so the values in this list become more and more accurate reflections of the communicative accuracy as you go through the list)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, this has given us our first simulation results! We can look at these as a big list, but it might be better to plot it as a graph. Try the following, for example:\n",
    "\n",
    "```python\n",
    "data = ca_monte(speaker, hearer, 100)\n",
    "plt.plot(data)\n",
    "plt.xlabel('trials')\n",
    "plt.ylabel('communicative accuracy')\n",
    "plt.ylim([0,1])\n",
    "plt.grid()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, this plots a single simulation run on a graph. More often, we want to plot lots of runs on a graph. We can do this by making a loop, and gathering a lot of simulation runs in a list. (This will actually be a list of lists now...)\n",
    "\n",
    "For example, we could do the following to get ten simulation runs:\n",
    "\n",
    "```python\n",
    "lots_of_data = []\n",
    "for n in range(10):\n",
    "    data = ca_monte(speaker, hearer, 100)\n",
    "    lots_of_data.append(data)\n",
    "\n",
    "print(lots_of_data)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmmm... I'm not sure we want to spend much time looking at screens full of numbers! Let's plot a graph!\n",
    "\n",
    "The following command produces a nicer visualisation of our data, showing all the graphs with transparent lines so we can see the aggregate behaviour of multiple simulations. See if you can figure out how this bit of code works. _Hint: in graphics \"alpha\" is a technical term for transparency._\n",
    "\n",
    "```python\n",
    "for data in lots_of_data:\n",
    "    plt.plot(data, color='orange', alpha=0.5)\n",
    "plt.xlabel('trials')\n",
    "plt.ylabel('communicative accuracy')\n",
    "plt.ylim([0,1])\n",
    "plt.grid()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful type of plot is a histogram showing a distribution of values. Let's say we wanted to know what the end result of a lot of simulation runs looked like. We need to do a little bit of work to pull out the last item of each run of a simulation and put it in a list. This code will do that:\n",
    "\n",
    "```python\n",
    "end_result = []\n",
    "for n in range(10):\n",
    "    data = ca_monte(speaker, hearer, 100)\n",
    "    last_item = data[len(data) - 1]\n",
    "    end_result.append(last_item)\n",
    "```\n",
    "\n",
    "Now we can plot the distribution using another handy plotting command, `hist`:\n",
    "\n",
    "```python\n",
    "plt.hist(end_result)\n",
    "plt.xlabel('communicative accuracy')\n",
    "plt.xlim([0, 1])    \n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, now we've had a bit of fun, let's understand what's going on!\n",
    "\n",
    "Try and understand what each function does. Look at the main function `ca_monte` first, then the function it calls (`communicate`), and so on until you have inspected each function separately. Can you see why the program has been divided into functions in the way it has? \n",
    "\n",
    "If you're not sure what each function does, you can have a look at the separate (very!) detailed walkthrough notebook I've provided on the Learn page. Work through that first and then come back here.\n",
    "\n",
    "When you are satisfied that you understand roughly how the code works, answer the following questions. 1-3 should be completed by everyone. **4 and 5 are optional!** Only attempt them if you are happy you have completed 1-3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. How many trials should there be in the Monte Carlo simulation to work out communicative accuracy? *Hint: answer this question empirically by plotting the results and comparing to what the \"real\" answer should be for various numbers of trials.*\n",
    "\n",
    "2. How do synonymy and homonymy affect communicative accuracy? Create production and reception systems with different degrees of homonymy and synonymy to explore this. *Note: you don’t have to start from the production and reception systems given above, and you don’t have to restrict yourself to systems with 3 meanings and 3 signals.*\n",
    "\n",
    "3. What alternatives to \"winner-take-all\" might there be in the model of production/ reception? What difference might this make? Would they be more or less realistic, or powerful as a model? *Hint: how might you interpret weights as probabilities?*\n",
    "\n",
    "4. **[optional]** How could you model production and reception using a single underlying matrix, rather than separate production and reception matrices? Is this kind of model better or worse than a model where we use separate matrices?\n",
    "\n",
    "5. **[optional]** How would you go about calculating communicative accuracy exactly, i.e. rather than via Monte Carlo techniques?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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": 1
}