{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e01e06b2e79cccf3",
   "metadata": {},
   "source": [
    "# Walkthrough Tutorial: the Canonical Naming Game\n",
    "\n",
    "<hr>\n",
    "\n",
    "This tutorial presents a PyFCG-powered implementation of the canonical naming game experiment, in which a population of agents converges on a naming convention used to refer to objects in their environment.\n",
    "\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ff621f74bb05072",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell if you have not yet installed these packages\n",
    "! pip install pyfcg\n",
    "! pip install numpy\n",
    "! pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8083dbf9f8429635",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:22.202225Z",
     "start_time": "2025-05-19T14:09:20.080985Z"
    }
   },
   "outputs": [],
   "source": [
    "import pyfcg as fcg\n",
    "import random\n",
    "import numpy as np\n",
    "\n",
    "fcg.init()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3088d52a29f69265",
   "metadata": {},
   "source": [
    "## Representating naming game agents"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c679a4a682d28b7c",
   "metadata": {},
   "source": [
    "A first step in setting up a language game experiment concerns the creation of a population of agents. We define our agents as instances of a new class ```NGAgent``` that subclasses from PyFCG's ```fcg.Agent``` class. The agents are thereby initialised with an empty grammar and inherit a collection of methods for interacting with instances of the ```fcg.Grammar``` and ```fcg.Construction``` classes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a28c56b6187d109b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:22.316589Z",
     "start_time": "2025-05-19T14:09:22.293488Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Agent: agent (id: agent-23) ~ 0 constructions>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The NGAgent subclasses from fcg.Agent\n",
    "\n",
    "class NGAgent(fcg.Agent):\n",
    "    \"\"\"\n",
    "    The NGAgent subclasses from fcg.Agent to inherit its linguistic capabilities. It defines\n",
    "    additional functionality to participate in a naming game.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        \"\"\"Defines a number of slots for this experiment\"\"\"\n",
    "        self.discourse_role = None\n",
    "        self.scene = None\n",
    "        self.topic = None\n",
    "        self.applied_cxn = None\n",
    "        self.competitor_cxns = None\n",
    "        self.utterance = None\n",
    "        self.communicated_successfully = False\n",
    "        # we call the init method of the fcg.Agent superclass\n",
    "        # to initialise the agent's grammar\n",
    "        super().__init__()\n",
    "\n",
    "    def clear(self):\n",
    "        \"\"\"Clear all data. \"\"\"\n",
    "        self.discourse_role = None\n",
    "        self.scene = None\n",
    "        self.topic = None\n",
    "        self.applied_cxn = None\n",
    "        self.competitor_cxns = None\n",
    "        self.utterance = None\n",
    "        self.communicated_successfully = False\n",
    "\n",
    "    def comprehend(self,utterance):\n",
    "        \"\"\" Comprehend utterance, collect meaning, applied_cxn and competitors. \"\"\"\n",
    "\n",
    "        meanings, applied_cxn_names_per_meaning = self.comprehend_all(utterance)\n",
    "        if meanings == [None]:\n",
    "            return None\n",
    "        else:\n",
    "            self.applied_cxn = self.find_cxn_by_name(applied_cxn_names_per_meaning[0][0])\n",
    "            self.competitor_cxns = []\n",
    "            for cxn_names in applied_cxn_names_per_meaning[1:]:\n",
    "                self.competitor_cxns.append(self.find_cxn_by_name(cxn_names[0]))\n",
    "            return meanings[0]\n",
    "\n",
    "    def formulate(self, meaning):\n",
    "        \"\"\"Formulate an utterance given a meaning. Use the highest-scored cxn and collect the competing constructions on the go. \"\"\"\n",
    "\n",
    "        utterances, applied_cxn_names_per_utterance = super().formulate_all(meaning)\n",
    "        if utterances == [None]:\n",
    "            return None\n",
    "        else:\n",
    "            self.utterance = utterances[0][0]\n",
    "            self.applied_cxn = self.find_cxn_by_name(applied_cxn_names_per_utterance[0][0])\n",
    "            self.competitor_cxns = []\n",
    "            for cxn_names in applied_cxn_names_per_utterance[1:]:\n",
    "                self.competitor_cxns.append(self.find_cxn_by_name(cxn_names[0]))\n",
    "            return self.utterance\n",
    "\n",
    "    def learn(self, form, meaning):\n",
    "        \"\"\" Create a new cxn given a form and a meaning. \"\"\"\n",
    "\n",
    "        new_cxn = fcg.Construction(name=form+'-cxn',\n",
    "                                   conditional_pole= [[\"?name-unit\",\n",
    "                                                        {\"#meaning\": [(meaning, \"?t\")]},\n",
    "                                                        {\"#form\": [(\"sequence\", '\\\"' + form + '\\\"', \"?left\", \"?right\")]}]],\n",
    "                                   attributes= {\"object\": meaning, \"name\": form, \"score\": 0.5})\n",
    "        self.add_cxn(new_cxn)\n",
    "        return new_cxn\n",
    "\n",
    "    def reward(self):\n",
    "        \"\"\" Reward through lateral inhibition. \"\"\"\n",
    "        inc_delta = CONFIGURATION['cxn_positive_reward']\n",
    "        dec_delta = CONFIGURATION['cxn_negative_reward']\n",
    "        if self.communicated_successfully:\n",
    "            # If success, reward the applied cxn and punish the competitors\n",
    "            self.applied_cxn.increase_score(delta=inc_delta)\n",
    "            for competitor in self.competitor_cxns:\n",
    "                competitor.decrease_score(delta=dec_delta)\n",
    "                # Delete cxns that reach a 0 score\n",
    "                if competitor.get_score() <= 0.0:\n",
    "                    self.delete_cxn(competitor)\n",
    "        else:\n",
    "            # If failure, speaker punishes applied cxn\n",
    "            if self.discourse_role == 'speaker':\n",
    "                self.applied_cxn.decrease_score(delta=dec_delta)\n",
    "                # Delete cxns that reach a 0 score\n",
    "                if self.applied_cxn.get_score() <= 0.0:\n",
    "                    self.delete_cxn(self.applied_cxn)\n",
    "\n",
    "NGAgent()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70539b8dbc7bf4df",
   "metadata": {},
   "source": [
    "The ```comprehend```, ```formulate``` and ```reward``` methods, as implemented for the ```NGAgent``` in the cell above, illustrate how high-level PyFCG functionality facilitates the implementation of language game experiments. Not only do ```comprehend``` and ```formulate``` return the highest-scored solution, they also yield all competing solutions as a second return value. Successfully used constructions can then be rewarded positively through calls to their ```increase_score``` method and their competitors can be rewarded negatively through calls to their ```decrease_score``` method. Constructions that reach a score of 0 can be deleted from an agent's grammar using the ```delete_cxn``` method."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76946ebdac51c33c",
   "metadata": {},
   "source": [
    "## Representing a naming game experiment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3da5850ad1814c72",
   "metadata": {},
   "source": [
    "We also define a new experiment class```NGExperiment```. Upon initialisation, a population is created as a set of ```NGAgent``` instances,  and a world is created as a set of abstract objects. Two methods are also associated to this class. The ```run_interaction``` method (cf. below) initiates a new communicative interaction as an instance of the ```NGInteraction``` class, makes the interaction happen, and records its outcome. The ```run_series``` method runs a given number of interactions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2f676664f1613efc",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:22.330433Z",
     "start_time": "2025-05-19T14:09:22.320922Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: alive_progress in /Users/paul/Projects/pyfcg/.venv/lib/python3.12/site-packages (3.2.0)\n",
      "Requirement already satisfied: about-time==4.2.1 in /Users/paul/Projects/pyfcg/.venv/lib/python3.12/site-packages (from alive_progress) (4.2.1)\n",
      "Requirement already satisfied: grapheme==0.6.0 in /Users/paul/Projects/pyfcg/.venv/lib/python3.12/site-packages (from alive_progress) (0.6.0)\n"
     ]
    }
   ],
   "source": [
    "! pip install alive_progress\n",
    "\n",
    "import alive_progress\n",
    "\n",
    "class NGExperiment():\n",
    "    \"\"\" The NGExperiment class holds the population and world and defines methods to run (series of) communicative interactions.\"\"\"\n",
    "\n",
    "    def __init__(self, configuration={}):\n",
    "        \"\"\"Upon initialisation, the world and population are created.\"\"\"\n",
    "        # The configuration passed to the experiment is merged with the default configuration.\n",
    "        global CONFIGURATION\n",
    "        CONFIGURATION = fcg.merge_dicts(CONFIGURATION,configuration)\n",
    "        # World and population are created.\n",
    "        self.world = ['obj-%d' % i for i in range(CONFIGURATION['nr_of_objects'])]\n",
    "        self.population = [NGAgent() for i in range(CONFIGURATION['nr_of_agents'])]\n",
    "        # With a new experiment, we also reset the monitors\n",
    "        global MONITORS\n",
    "        MONITORS = {}\n",
    "\n",
    "    def run_interaction(self):\n",
    "        \"\"\" Create a new interaction, make it happen and record the outcome. \"\"\"\n",
    "        interaction = NGInteraction(self)\n",
    "        interaction.interact()\n",
    "        interaction.record_communicative_success()\n",
    "        interaction.record_lexicon_size()\n",
    "        interaction.record_conventionality()\n",
    "\n",
    "    def run_series(self, nr_of_interactions):\n",
    "        \"\"\"Run a series of interactions.\"\"\"\n",
    "        with alive_progress.alive_bar(nr_of_interactions, force_tty=True) as bar:\n",
    "            for i in range(nr_of_interactions):\n",
    "                self.run_interaction()\n",
    "                bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65061adbe6b2052b",
   "metadata": {},
   "source": [
    "## Representing a communicative interaction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d337e66e0cf583b1",
   "metadata": {},
   "source": [
    "The ```interact``` method of the ```NGInteraction``` class defines the script according to which each communicative interaction takes place. A randomly selected agent, the speaker, formulates an utterance to draw the attention of another randomly selected agent, the hearer, to a randomly selected object in the environment, the topic. If there exists no construction in the speaker's grammar that associates a name with the topic object, the speaker calls its ```learn``` method to invent such a construction. The hearer then calls its ```comprehend``` method to retrieve the topic object in the environment, and its ```learn``` method in case it could not understand. The agents achieve communicative success if the hearer could identify the topic object, and both agents will positively or negatively reward their constructions at the end of the interaction, based on its outcome.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5ae66ff86033600a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:22.344714Z",
     "start_time": "2025-05-19T14:09:22.339565Z"
    }
   },
   "outputs": [],
   "source": [
    "class NGInteraction():\n",
    "    \"\"\" The NGInteraction implements the interaction script of the Naming Game experiment. \"\"\"\n",
    "\n",
    "    def __init__(self, experiment):\n",
    "        \"\"\"Upon initialisation, sample interacting agents and scene.\"\"\"\n",
    "        self.experiment = experiment\n",
    "        # choose 2 interacting agents at random\n",
    "        self.interacting_agents = random.sample(self.experiment.population, 2)\n",
    "        # Sample a new scene\n",
    "        self.scene = random.sample(self.experiment.world, CONFIGURATION['nr_of_objects'])\n",
    "        # Clear and re-initialise the interacting agents\n",
    "        for agent in self.interacting_agents:\n",
    "            agent.clear()\n",
    "            agent.scene = self.scene\n",
    "            # the first object of the randomly created scene functions as the topic:\n",
    "            agent.topic = self.scene[0]\n",
    "        # Assign discourse roles\n",
    "        self.speaker = self.interacting_agents[0]\n",
    "        self.hearer = self.interacting_agents[1]\n",
    "        self.speaker.discourse_role = 'speaker'\n",
    "        self.hearer.discourse_role = 'hearer'\n",
    "\n",
    "    def interact(self):\n",
    "        \"\"\"Defines the interaction script.\"\"\"\n",
    "        # Run the speaker side (production and possibly invention)\n",
    "        self.speaker.utterance = self.speaker.formulate([[self.speaker.topic, \"t\"]])\n",
    "        if self.speaker.utterance is None:\n",
    "            self.speaker.learn(fcg.generate_word_form(), self.speaker.topic)\n",
    "            self.speaker.utterance = self.speaker.formulate([[self.speaker.topic, \"t\"]])\n",
    "        # Pass the utterance to the hearer\n",
    "        self.hearer.utterance = self.speaker.utterance\n",
    "        # Run the hearer side (parsing and possibly adoption)\n",
    "        if self.hearer.comprehend(self.hearer.utterance) is None:\n",
    "            self.hearer.topic = self.scene[0] # pointing\n",
    "            self.hearer.learn(self.hearer.utterance, self.hearer.topic)\n",
    "        else:\n",
    "            self.speaker.communicated_successfully = True\n",
    "            self.hearer.communicated_successfully = True\n",
    "        # Reward the agents, positively and/or negatively\n",
    "        for agent in self.interacting_agents:\n",
    "            agent.reward()\n",
    "\n",
    "    def record_communicative_success(self):\n",
    "        \"\"\" Record communicative success of the interaction \"\"\"\n",
    "        success = all([agent.communicated_successfully for agent in self.interacting_agents])\n",
    "        if success:\n",
    "            notify('communicative_success', 1)\n",
    "        else:\n",
    "            notify('communicative_success', 0)\n",
    "\n",
    "    def record_lexicon_size(self):\n",
    "        \"\"\" Record the average lexicon size across the population. \"\"\"\n",
    "        agents_with_cxns = [agent for agent in self.experiment.population if agent.grammar_size() > 0]\n",
    "        avg_nr_of_cxns = np.mean([agent.grammar_size() for agent in agents_with_cxns])\n",
    "        notify('construction_inventory_size', avg_nr_of_cxns)\n",
    "\n",
    "    def record_conventionality(self):\n",
    "        \"\"\" Record the lexicon coherence between speaker and hearer \"\"\"\n",
    "        speaker = self.speaker\n",
    "        hearer = self.hearer\n",
    "        if not speaker.communicated_successfully:\n",
    "            notify('conventionality', 0)\n",
    "        else:\n",
    "            hearer_form = hearer.formulate([[hearer.topic, \"o\"]])\n",
    "            if speaker.utterance == hearer_form:  ##check!\n",
    "                notify('conventionality', 1)\n",
    "            else:\n",
    "                notify('conventionality', 0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e78f96907fbcb5e",
   "metadata": {},
   "source": [
    "## Monitors and plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "793809bfd92bc05d",
   "metadata": {},
   "source": [
    "We create a number of helper functions for monitoring and plotting the results of the experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cf5027b579b1625",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:22.351497Z",
     "start_time": "2025-05-19T14:09:22.348623Z"
    }
   },
   "outputs": [],
   "source": [
    "from itertools import islice\n",
    "\n",
    "def notify(monitor, value):\n",
    "    \"\"\" Notify will add 'value' to the 'monitor' key in the global variable MONITORS. \"\"\"\n",
    "    if monitor in MONITORS:\n",
    "        MONITORS[monitor].append(value)\n",
    "    else:\n",
    "        MONITORS[monitor] = [value]\n",
    "\n",
    "\n",
    "def window(seq, n=2):\n",
    "    \"\"\" Returns a sliding window (of width n) over the data from the sequence. \"\"\"\n",
    "    it = iter(seq)\n",
    "    result = tuple(islice(it, n))\n",
    "    if len(result) == n:\n",
    "        yield result\n",
    "    for elem in it:\n",
    "        result = result[1:] + (elem,)\n",
    "        yield result\n",
    "\n",
    "\n",
    "def make_plot_points(monitors, window_size=100):\n",
    "    \"\"\" Creates a new dictionary with the averages of the sliding windows, using the same keys as the monitors. \"\"\"\n",
    "    plot_points = {}\n",
    "    for key in monitors:\n",
    "        plot_points[key] = []\n",
    "        generator = window(monitors[key], n=window_size)\n",
    "        for w in generator:\n",
    "            plot_points[key].append(np.mean(w))\n",
    "    return plot_points"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b0449c7f228a96a",
   "metadata": {},
   "source": [
    "## Running a naming game experiment with a population of FCG agents."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "204fec27ea5ceeee",
   "metadata": {},
   "source": [
    "An experiment can be run by first creating a new instance of the ```NGExperiment``` class and then calling its ```run_series``` method, passing the desired number of interactions as an argument. Let us first define a number of default configurations for the experiment:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e7ae04d76bc40563",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:22.358155Z",
     "start_time": "2025-05-19T14:09:22.356351Z"
    }
   },
   "outputs": [],
   "source": [
    "# Default configuration settings #\n",
    "##################################\n",
    "\n",
    "# The experiment configuration can be overwritten by passing a configuration dict\n",
    "# when instantiating an experiment.\n",
    "CONFIGURATION = {\n",
    "    'nr_of_agents': 10,\n",
    "    'nr_of_objects': 10,\n",
    "    'cxn_positive_reward': 0.1,\n",
    "    'cxn_negative_reward': 0.2\n",
    "}\n",
    "\n",
    "# We will store monitoring data for the experiment under a global variable.\n",
    "MONITORS = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "478cd9fe349de1b7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:57.192086Z",
     "start_time": "2025-05-19T14:09:22.362991Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|████████████████████████████████████████| 2500/2500 [100%] in 13.8s (181.50/s) \n"
     ]
    }
   ],
   "source": [
    "experiment = NGExperiment({'nr_of_agents': 10, 'nr_of_objects': 5})\n",
    "experiment.run_series(2500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7d9d753d81b8cb3",
   "metadata": {},
   "source": [
    "## Visualising the results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f65a2b08070b18fb",
   "metadata": {},
   "source": [
    "The results of an experiment can be visualised using any plotting library from Python's extensive ecosystem, such as ```matplotlib```, ```seaborn``` or ```plotly```. We demonstrate here the use of ```matplotlib``` to visualise the experiment's dynamics through graphs, where the degree of communicative success, degree of conventionality and average number of constructions are plotted in function of the number of interactions that have taken place.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e01828fecb5821c9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-19T14:09:57.684833Z",
     "start_time": "2025-05-19T14:09:57.198751Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x700 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "pp = make_plot_points(MONITORS, window_size=100)\n",
    "# for each key in plot points (pp), create a plot\n",
    "fig, axes = plt.subplots(len(pp.keys()), figsize=(5, 7), sharex=True)\n",
    "\n",
    "for i, key in enumerate(pp.keys()):\n",
    "    ax = axes[i]\n",
    "    ax.plot(list(range(len(pp[key]))), pp[key], label=key)\n",
    "    ax.grid()\n",
    "    ax.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bd1aeaa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}