simlang_7_lab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulating Language 7, Signalling in populations (lab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook extends the first signalling program by measuring communicative accuracy among a population of agents. Most of the code is the same as the first, with the exception of the pop_update function; we also store more information about each of the agents, as described in the comments below.\n",
    "\n",
    "Make sure you understand the complex embedded list structure described:\n",
    "- a population is a list of agents;\n",
    "    - an agent is a list containing three items: a production system, a reception system, and a set of scores;\n",
    "        - a production system is a matrix of association weights (i.e. a list of lists); \n",
    "        - a reception system is a matrix of association weights (i.e. a list of lists); \n",
    "        - the set of scores is a list of four integers.\n",
    "        \n",
    "Here's an example population:\n",
    "\n",
    "```python\n",
    "population = [[[[3, 1], [0, 2]], [[1,0], [2,4]], [0, 0, 0, 0]],\n",
    "              [[[1, 0], [0, 1]], [[2,0], [0,1]], [0, 0, 0, 0]],\n",
    "              [[[0, 1], [1, 0]], [[0,1], [1,0]], [0, 0, 0, 0]]]\n",
    "```\n",
    "\n",
    "*How would you access the production matrix for the first agent in the population? How about the set of scores for the last agent in the population?*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the code we'll be reusing from the previous notebook from Lab 2 again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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')\n",
    "\n",
    "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're going to add some new code to handle a **population** of agents, rather than single agents like we did before.\n",
    "\n",
    "`pop_update` takes a list of agents and picks two at random to be producer and receiver for a random meaning. Each agent consists of a production system, a reception system and a list of 4 scores: the number of times they have successfully been understood as speaker, the number of times they have spoken, the number of times they have successfully understood as hearer, and the number of times they have been hearer, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pop_update(population):\n",
    "    speaker_index = random.randrange(len(population))\n",
    "    hearer_index = random.randrange(len(population) - 1)\n",
    "    if hearer_index >= speaker_index: \n",
    "        hearer_index += 1\n",
    "    speaker = population[speaker_index]\n",
    "    hearer = population[hearer_index]\n",
    "    meaning = random.randrange(len(speaker[0]))\n",
    "    success = communicate(speaker[0], hearer[1], meaning)\n",
    "    speaker[2][0] += success\n",
    "    speaker[2][1] += 1\n",
    "    hearer[2][2] += success\n",
    "    hearer[2][3] += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try using the population list you made above and then running the population update in a loop like this:\n",
    "\n",
    "```python\n",
    "population = [[[[3, 1], [0, 2]], [[1,0], [2,4]], [0, 0, 0, 0]],\n",
    "              [[[1, 0], [0, 1]], [[2,0], [0,1]], [0, 0, 0, 0]],\n",
    "              [[[0, 1], [1, 0]], [[0,1], [1,0]], [0, 0, 0, 0]]]\n",
    "\n",
    "for i in range(10000): \n",
    "    pop_update(population)\n",
    "\n",
    "print(population)\n",
    "```\n",
    "\n",
    "This will do the following, 10000 times: pick one of these three agents to be speaker and another to be hearer, have them communicate, and update their scores accordingly. Make sure you understand why the output looks the way it does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look `pop_update` and check you understand how it works.\n",
    "\n",
    "- How does the program ensure that the same agent does not play both roles?\n",
    "- What scores are updated after a communication event, and why?\n",
    "\n",
    "Work through the following questions: these go from easy to hard, everyone should answer 1 and 2, 3-5 are optional and can involve as much or as little coding as you like.\n",
    "\n",
    "1. The two ways of scoring an agent's success depend on being understood (the first number), and understanding (the third number). What are the ecological interpretations of these scores? Which do you think are evolutionarily significant, and why?\n",
    "2. Can you construct a population where every agent gets approximately the same score for being understood, but different scores for understanding? What about the other way round?\n",
    "3. **[optional]** How would you adjust this code to keep a trial-by-trial record of the communicative accuracy of the population by trial number? Hint: look at how this was achieved in the `simlang_5_lab`. \n",
    "4. **[optional]** Who communicates with who in a population? What other ways could you model this, and how would you start adjusting the code to implement your model? Hint: what if people only talked to people who were ‘near’ them? \n",
    "5. **[optional]** Rather than explicitly providing a population to evaluate, can you come up with some code that generates a population of a specified size with random production and reception matrices?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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
}