From eccdfd6f2edb525c6044916b00d956955c5346d1 Mon Sep 17 00:00:00 2001 From: Sheridan Kates Date: Sun, 22 May 2022 05:57:59 +0100 Subject: [PATCH 1/5] Added local dev stuff to .gitignore --- .gitignore | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 58461f2..847a8b8 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,3 @@ -.ipynb_checkpoints \ No newline at end of file +.ipynb_checkpoints +venv +.vscode \ No newline at end of file From 6e30a732e44322d2689a1278082117a08b829a69 Mon Sep 17 00:00:00 2001 From: Sheridan Kates Date: Fri, 3 Jun 2022 14:51:13 +0100 Subject: [PATCH 2/5] Adapt model for popular agent support --- 05_Social_Support_ABM.ipynb | 332 +++++++++++++++++++++++++++--------- 1 file changed, 250 insertions(+), 82 deletions(-) diff --git a/05_Social_Support_ABM.ipynb b/05_Social_Support_ABM.ipynb index 20d3642..ba37ecf 100644 --- a/05_Social_Support_ABM.ipynb +++ b/05_Social_Support_ABM.ipynb @@ -5,7 +5,7 @@ "id": "static-collection", "metadata": {}, "source": [ - "# An agent-based model of social support" + "# Weighting of friends in agent-based models of social support\n" ] }, { @@ -13,7 +13,7 @@ "id": "changing-jones", "metadata": {}, "source": [ - "*Joël Foramitti, 10.02.2022*" + "_Sheridan Kates, 03.06.2022_\n" ] }, { @@ -21,21 +21,22 @@ "id": "actual-warren", "metadata": {}, "source": [ - "This notebook introduces a simple agent-based model to explore the propagation of social support through a population." + "[This notebook by Joël Foramitti](https://github.com/JoelForamitti/ses_modeling_course/blob/main/05_Social_Support_ABM.ipynb) introduced a simple agent-based model to explore the propagation of social support through a population. The purpose of this notebook is to try to adapt it to model the effect of different levels of support among the popular agents in the model (i.e. those with more than average friend connections), to model how that might affect successful outcomes of support for a cause. Edits from the original code are called out in comments marked `(sheridan)`, and additions to the text are in bold italics (like this one).\n" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 8, "id": "circular-underwear", "metadata": {}, "outputs": [], "source": [ - "import agentpy as ap \n", + "import agentpy as ap\n", "import networkx as nx\n", "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "sns.set_theme()" + "import os\n", + "\n", + "sns.set_theme()\n" ] }, { @@ -47,34 +48,33 @@ "\n", "At every time-step, an agent interacts with their friends as well as some random encounters.\n", "\n", - "The higher the perceived support amongst their encounters, the higher the likelyhood that the agent will also support the cause." + "The higher the perceived support amongst their encounters, the higher the likelihood that the agent will also support the cause.\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "id": "quarterly-suggestion", "metadata": {}, "outputs": [], "source": [ "class Individual(ap.Agent):\n", - " \n", " def setup(self):\n", - " \n", + "\n", " # Initiate a variable support\n", " # 0 indicates no support, 1 indicates support\n", " self.support = 0\n", - " \n", + "\n", " def adapt_support(self):\n", - " \n", + "\n", " # Perceive average support amongst friends and random encounters\n", " random_encounters = self.model.agents.random(self.p.random_encounters)\n", " all_encounters = self.friends + random_encounters\n", " perceived_support = sum(all_encounters.support) / len(all_encounters)\n", - " \n", + "\n", " # Adapt own support based on random chance and perceived support\n", " random_draw = self.model.random.random() # Draw between 0 and 1\n", - " self.support = 1 if random_draw < perceived_support else 0" + " self.support = 1 if random_draw < perceived_support else 0\n" ] }, { @@ -82,59 +82,93 @@ "id": "collected-membrane", "metadata": {}, "source": [ - "At the start of the simulation, the model initiates a population of agents, defines a random network of friendships between these agents, and chooses a random share of agents to be the initial supporters of the cause. \n", + "At the start of the simulation, the model initiates a population of agents, defines a random network of friendships between these agents, and chooses a random share of agents to be the initial supporters of the cause.\n", + "\n", + "The major change in the model logic is here. Instead of assigning the support randomly across all agents in the model, we now use the `popular_agent_support_multiplier` to alter now much support there is among the popular agents (i.e. those with the most connections) for the cause, while still ensuring the same amount of support for the cause overall.\n", "\n", - "At every simulation step, agents change their support and the share of supporters is recorded. \n", + "At every simulation step, agents change their support and the share of supporters is recorded.\n", "\n", - "At the end of the model, the cause is designated a success if all agents support it." + "At the end of the model, the cause is designated a success if all agents support it.\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 10, "id": "single-bobby", "metadata": {}, "outputs": [], "source": [ "class SupportModel(ap.Model):\n", - " \n", " def setup(self):\n", - " \n", + "\n", " # Initiating agents\n", " self.agents = ap.AgentList(self, self.p.n_agents, Individual)\n", - " \n", + "\n", " # Setting up friendships\n", " graph = nx.watts_strogatz_graph(\n", - " self.p.n_agents, \n", - " self.p.n_friends, \n", - " self.p.network_randomness)\n", + " self.p.n_agents, self.p.n_friends, self.p.network_randomness\n", + " )\n", " self.network = self.agents.network = ap.Network(self, graph=graph)\n", " self.network.add_agents(self.agents, self.network.nodes)\n", " for a in self.agents:\n", " a.friends = self.network.neighbors(a).to_list()\n", - " \n", + "\n", " # Setting up initial supporters\n", " initial_supporters = int(self.p.initial_support * self.p.n_agents)\n", - " for a in self.agents.random(initial_supporters):\n", - " a.support = 1\n", - " \n", + "\n", + " # (sheridan) This is the core of how we model higher support amoung popular agents. On average, everyone\n", + " # in the model has n_friends - but the Watts Strogatz graph randomises friend connections such that some\n", + " # people have more friends than others.\n", + " # We find those popular agents (i.e. those that have more than the initially-specified number of friends),\n", + " # and make them more likely than the average to support the case, based on the popular_agent_support_multiplier.\n", + "\n", + " popular_agents = self.agents.select(\n", + " list(map(lambda a: len(a.friends) > self.p.n_friends, self.agents))\n", + " )\n", + "\n", + " # (sheridan) The regular agents are just those that are in the agent list, but aren't popular\n", + " regular_agents = self.agents.select(\n", + " list(map(lambda a: a not in popular_agents, self.agents))\n", + " )\n", + "\n", + " # (sheridan) In order to make sure that the popular_agent_support_multiplier doesn't take the number of popular supporters\n", + " # greater than the actual number of popular_agents that exists, we clamp the number of popular supporters down to the\n", + " # length of the popular agents list if it ends up higher than that.\n", + " initial_popular_supporters = int(\n", + " min(\n", + " (self.p.initial_support * self.p.popular_agent_support_multiplier)\n", + " * len(popular_agents),\n", + " len(popular_agents),\n", + " )\n", + " )\n", + " # (sheridan) So that we're not influencing the amount of support overall, we need to make sure that the overall initial_support\n", + " # level is whatever was passed in. So we subtract the number of supporting popular agents from the overall required supporter count.\n", + " initial_regular_supporters = initial_supporters - initial_popular_supporters\n", + "\n", + " # Randomly assign the calculated number of supporters in each of the popular and regular sets.\n", + " for popular_agent in popular_agents.random(initial_popular_supporters):\n", + " popular_agent.support = 1\n", + " for regular_agent in regular_agents.random(initial_regular_supporters):\n", + " regular_agent.support = 1\n", + "\n", " def step(self):\n", - " \n", + "\n", " # Let every agent adapt their support\n", " self.agents.adapt_support()\n", "\n", " def update(self):\n", - " \n", + "\n", " # Record the share of supporters at each time-step\n", " self.supporter_share = sum(self.agents.support) / self.p.n_agents\n", - " self.record('supporter_share')\n", - " \n", + " self.record(\"supporter_share\")\n", + "\n", " def end(self):\n", - " \n", - " # Report the success of the social movement \n", + "\n", + " # Report the success of the social movement\n", " # at the end of the simulation\n", + "\n", " self.success = 1 if self.supporter_share == 1 else 0\n", - " self.model.report('success')" + " self.model.report(\"success\")\n" ] }, { @@ -144,7 +178,7 @@ "source": [ "For the generation of the network graph, we will use the [Watts-Strogatz model](https://en.wikipedia.org/wiki/Watts%E2%80%93Strogatz_model). This is an algorithm that generates a regular network were every agent will have the same amount of connections, and then introduces a certain amount of randomness to change some of these connections. A network where most agents are not neighbors, but where it is easy to reach every other agent in a small number of steps, is called a [small-world network](https://en.wikipedia.org/wiki/Small-world_network).\n", "\n", - "\"drawing\"" + "\"drawing\"\n" ] }, { @@ -152,29 +186,30 @@ "id": "necessary-douglas", "metadata": {}, "source": [ - "## A single-run simulation" + "## A single-run simulation\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 11, "id": "demanding-split", "metadata": {}, "outputs": [], "source": [ "parameters = {\n", - " 'steps': 100,\n", - " 'n_agents': 100,\n", - " 'n_friends': 2,\n", - " 'network_randomness': 0.5,\n", - " 'initial_support': 0.5, \n", - " 'random_encounters': 1\n", - "}" + " \"steps\": 100,\n", + " \"n_agents\": 100,\n", + " \"n_friends\": 2,\n", + " \"network_randomness\": 0.5,\n", + " \"initial_support\": 0.5,\n", + " \"random_encounters\": 1,\n", + " \"popular_agent_support_multiplier\": 2,\n", + "}\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "id": "subtle-outline", "metadata": {}, "outputs": [ @@ -183,7 +218,7 @@ "output_type": "stream", "text": [ "Completed: 100 steps\n", - "Run time: 0:00:00.174389\n", + "Run time: 0:00:00.161459\n", "Simulation finished\n", "Success: Yes\n" ] @@ -192,19 +227,19 @@ "source": [ "model = SupportModel(parameters)\n", "results = model.run()\n", - "success = 'Yes' if model.success else 'No'\n", - "print(f'Success: {success}')" + "success = \"Yes\" if model.success else \"No\"\n", + "print(f\"Success: {success}\")\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "id": "comprehensive-battery", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAEJCAYAAACAKgxxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAA3Z0lEQVR4nO3deXgb5bU/8O9ot7zJiyRnTyA72EkoAWPAEFo3wYmBS1ICoZgSMNCWhvpyaVjCZfk1hRSou3C5lBS4bUloAgWMQzCGpmxxKE1YspGNxEmIbcm2bGvf5/eHNGPZli3J1mLNnM/z5HkiaSy/Y9lHr86c97wMy7IsCCGECIYk1QMghBASXxTYCSFEYCiwE0KIwFBgJ4QQgaHATgghAkOBnRBCBIYCOyGECIws1QMAgO5uG/z+2MvpCwqy0NVlTcCIxi46Z3GgcxaHkZ6zRMIgLy9zyMfHRGD3+9kRBXbua8WGzlkc6JzFIRHnTKkYQggRGArshBAiMGMiFRMOy7Lo7u6A2+0EEP6jitEogd/vT+7AUizdz1kqlSErS4OMjKHzg4SQ0Yk6sFutVlx//fV47rnnMHHixH6Pff3111i3bh2sVivOP/98PProo5DJRveeYbX2gmEY6PUTwTDhP1jIZBJ4vekb5EYinc+ZZVl4PG709HQAAAV3QhIkqlTMV199hRtuuAEtLS1hH7/33nvx0EMP4d133wXLsti6deuoB+ZwWJGdrRkyqJP0wzAMFAolNBotrNaeVA+HEMGKKmpu3boVDz/8MHQ63aDHzpw5A6fTifnz5wMArr32WjQ2No56YH6/D1LpmM0UkVGQyxXw+bypHkZcsCwLfyL++RP0vGP5nwjPOVGiipzr168f8jGj0QitVsvf1mq1MBgMox8ZAjM8IjxCeV3tTi/++8V/wWR2pXooJA0xDLD2poWYOT477s896ilxuH06Yv3DLSjIGnSf0SiBTBb5A0U0xwjBxx9/iNOnT2PVqh8m5JxbW1vxk5/U4M033477c4cjkUig1Ub/Cx3Lscnyt/cOw2R2Yfmi6VAq6NMliY1EAsyemoeC3Iy4P/eofxv1ej06Ozv52x0dHWFTNsPp6rIOKtL3+/0RLxKm84XEWB08eJD/fyLO2efzJ+y5w/H7/ejosER1rFabHfWxyWJ3evHGP49hwYxCLL1wctyffyyec6KJ8ZwLcjNGdM4SCRN2QswZdWCfMGEClEol9uzZg+985zt48803UV5ePtqnHVOMRgMee+whOBwOSCQM7r77XjzyyAP4wx/+iHHjxuPzz3fjxRefxzPPPI+77rodU6dOw8GD++F2u7FmzT244IJSrF//CBiGwfHj38BqteJHP7oVS5YshdPpxIYNv8SxY0cgkUhw/fU/xJVXLsP27Q14551t6O3twcSJk7F//14AwIQJ41Fe/l385jcbcPz4N/D7/bjxxmpUVCzp9zUXX1yOO+74adjz2b37Mzz77O/BMAyys7PxyCO/AgC4XC48/PD9OH78G2Rn5+Dxx59Cbq4Gf//7FjQ2bofT6YBEIsGjjz6OqVOnYcWKKsydey6OHj2MZ5/9Ez79tBmvvvoK/H4Ws2bNxn/+51oolcqkvU7J9P6e07C7vLjq4mmpHgohg4w4sNfU1GDNmjUoLi7GU089hXXr1sFms2Hu3Lmorq6O5xixc18bPtnbNuh+hgFGe/3hkpJxuLh43LDHbNtWj7KyS7BqVTU+/3w39u79ctjj3W43XnxxE44ePYz/+q81eO21bQCAjg4jnnvuRZhMXbj11puwcOGF2LJlE3Jzc/HXv25FT08PampuxowZs/jjX375VchkMrzwwh8BAMuWXY0//OF3mDVrDtatexQ2mxV33rkac+eeO+hrhvLnP7+Ae++9H3PmnINXX/0bjhw5hEmTJqOnpxsrV96IuXPPxbp1v8D77zdhyZJKfPTRh3jmmT9CqVThT396Dm+88Spqa38BACgtLcNjjz2O48e/QUPDm/jf/30RSqUSzz33DF555a/40Y9ui+p1SCd2pxdNn53GghmFmFI09lJEhMQU2Hfs2MH/f+PGjfz/Z8+ejddeey1+oxpjzj//Ajz44C9w5MhhlJVdguXLr8Prrw9d0nnVVf8BAJgxYxYKCgrxzTdHAQCVlVWQyWTQ6fQoLp6HvXu/xJ49u3HffQ8BADQaDS69tBxffLEHmZmZmDlzdtgAvXv3Z3C5nHj77bcAAE6nEydOHAeAIb8m1CWXlOOBB+7FpZdehksvvQwLF5aira0VhYVa/g1i2rSz0dvbg8zMLDzyyC/x/vtNOH36FP71r2b+jQcAf/wXX+zGt9+exh133AIA8Ho9mDlzduQfbhqi2ToZ69Liis/FxeFn1cnKsZeUzMfLL29Fc/Mn+Mc/mrB9ewMYhuEvHA8s3ZNKpfz//X6Wvx1avsmyfkilMrBs//GzbN/zDZXG8Pt9eOih/4dZswKB02TqQk5OLpqa3okq9bFy5Y24+OJyNDd/jGef/T0uv/wAvv/9K/uNOzAWFgZDO372szuwfPl1KC0tQ35+AY4ePcwfw30/n8+PK674Hn7+83sBAHa7HT6fL+JY0o3H66fZOhnzxFFSMkrPPvs7vPvudlx55TLU1q7FkSOHkZur4WfJH3/8Yb/j33+/CQBw6NBBWCxmnHXWdADAjh3vgWVZtLe34eDB/Zg3bz7OO28h3n67HgDQ09ODjz/+AAsWnD9oDFKplA+U5523EG++GfiE1NnZiZtvvgEGQ3vU51NTczPsdhuuu24VrrtuFY4cOTTksYcOHcTEiZP4FM2nnzbD7x8csBcs+A4++ugDdHebwLIsnn76cWzdujnqMaWLzl4H7C4vzp8VW4EAIcmUFjP2VFu+fCUefXQdtm/fBolEgnvuuQ9qdQbq6p7ESy9txAUXlPY7vrX1DFavvhEA8Oijj/MzYZfLiVtvvQkejxv33vsgcnM1uOWW2/D00xtQXb0Sfr8f1dWrMWvWbD59w5k//zysX/8ICgsLsXp1DZ5+egNuuuk6+P1+/OQnazBhwkR89dUXUZ3PHXf8FOvXPwqpVAqlUol7771/yGMXLizFG2+8hh/+8AeQy+WYO/dcHD/+zaDjZsyYiVtuqcGaNXeCZVnMmDELP/zhj6IaTzrp7HUCAAo1qhSPhJChMWy4QvQkC1fu2N5+EkVFU4b9urFY7njXXbdj9erbcd55/Wfd69c/ggULvoPKyqpRPf9YPOeRiOb15YylMrh/fnEGf333MJ7+6cXIy05cxc9YOudkoXOOXsLLHcnYtGXLJrzzzuDFRoWFhXjqqd+nYETC0NnrgFTCIDdLkeqhEDIkCuxx9swzz4e9/8EHH0nqOFauvBErV96Y1O8pBl29ThTkqiARSFsEIkx08ZSQGHT2OlGYS/l1MraN6cA+BtL/JAECJZ7pOeOlwE7SwZgN7DKZAjabmYK7gLAsC6/Xg56eTigU6Rcc3R4fzDZ3Qpo2ERJPYzbHnpenRXd3x7AbMkgk6b1N3Eik+zlLJFJkZGQhKys31UOJWZc5WOpIM3Yyxo3ZwC6VylBYOHwPFyqPIsnE17BTYCdj3JhNxRAy1vQFdkrFkLGNAjshUaIadpIuKLATEiWqYSfpggI7IVGiUkeSLiiwExIlCuwkXVBgJyQKVMNO0gkFdkKiQDXsJJ1QYCckClTDTtIJBXZCokA17CSdUGAnJApUw07SSVSBvaGhAZWVlaioqMCmTZsGPf7hhx+iqqoKVVVVuOeee2Cz2eI+UEJSiWrYSTqJGNgNBgPq6uqwefNm1NfXY8uWLTh27Bj/uNlsxn333Ye6ujo0NDRg9uzZqKurS+igCUk2KnUk6SRiYG9ubkZpaSk0Gg3UajUWL16MxsZG/vGWlhaMHz8e06dPBwAsWrQI77//fuJGTEgKUGAn6SRiYDcajdBqtfxtnU4Hg8HA3546dSra29tx6NAhAMA777yDzs7OBAyVkNSgGnaSbiK27Q230QUTkmfMycnBhg0b8NBDD8Hv9+O6666DXC6PaRDD7bYdiVabPeKvTVd0zsnV0mYGAJw9KS+p46DXWRwScc4RA7ter8fu3bv520ajETqdjr/t8/lQVFSEV199FQBw4MABTJo0KaZBdHVZ4ffHvlOSGHuT0zkn3/4jRgBAtlKatHGk+pxTgc45ehIJM+yEOGIqpqysDLt27YLJZILD4UBTUxPKy8v5xxmGwerVq2EwGMCyLF588UVUVlbGPFBCxqoznTYwDFCUr071UAiJSsTArtfrUVtbi+rqalxzzTVYtmwZSkpKUFNTg3379kEikeCxxx7DbbfdhiVLliA7Oxu33nprMsZOSFK0ddqgy1NDLqNlHyQ9RLU1HlejHmrjxo38/y+//HJcfvnlcR0YIWPFmU4bJhRmpnoYhESNpiCEDMPj9cPY7cB4CuwkjVBgJ2QYBpMdfpalGTtJKxTYCRnGmc5AewyasZN0QoGdjMqBEyZ09jpSPYyEOdNpg4RhqCKGpBUK7GTEPF4/fvfaXrz+0fFUDyVhWjtt0OVlUEUMSSv020pG7EynFV6fH4dP9YRdoSwErZ02SsOQtEOBfYCDLSbYnJ5UDyMttLQHVsx1W1ww9ggvHUMVMSRdUWAP4XL78PSWL/Hev0+neihp4WS7BVJJoG/Q4VM9qR1MArRTRQxJUxTYQ5jtbrAscNpoTfVQ0kJLuwUzJ2mQk6nAoVPdqR5O3LUGK2IosJN0Q4E9hNnuBgC0dtmHPe5kuwU9VlcyhtSP0+3FgeNdSf++4Xi8fnxrtGLquGzMnqwRZJ6dq4jRU0UMSTMU2ENY7IHcurHbDo/XF/YYlmXx9JYv8dd3DydzaACAtz5pwQP/uxMud/ixJdOZTit8fhZTi3Iwe3JeIM/eLaw8O1XEkHRFv7EhLMEZO8sCbUPM2nusblgdHuw73gWHy5u0sbEsi88OGeD3s7An8fsOhbtwOqUoG7MmawBAcOmYVuoRQ9IUBfYQ3IwdAFq7wm/Izd3v9bH48mjydoo63mqGyRxI/yTzDWUoJ9styFTJoM1VoShfjdxMhaAuoHIVMeMosJM0RIE9hMXuhkwqgYRh+AtnA7V2BO7PVMnw70PGpI0t9Hs53KkP7C3tFkzWZ4NhGDAMg1mTNTh0qlswefaWdjP8LItJupHv7kVIqlBgD2Gxe5CbKYc+PwNnOsIH9jOdNmRlyFF27jjsP5GcdAzLsth92IgcdWDLQacrtTl2/sJpUd+WXrMn56HH6hZMnn33oQ7IpBKcOy0/1UMhJGYU2EOY7W5kqxUYX5A5ZGVMa5cN4wvUWDhbl7R0DJeGKTt3HIDUp2L4C6fjcvj7hJRn9wffSM+dlo8MZVRbFhAyplBgD2GxewKBvTAzbGUMy7Jo7bBhvDYLZ03IQV62MinpmH8fMkImZXDRuUUAUh/YQy+ccory1chRy/HNGXOqhhU3x8+Y0W1xYeEcXeSDCRmDKLCHsNrdyFHLMUGbGbYypsfqht3lxYTCTEgYBufP0mH/iS7YnYkLtNzs8Zyp+SjIUQIAHCkudwy9cMphGAa6fLUgOj1+dsgAmVSC+dMLUz0UQkaEAnsQy7IwczP2gkAlxMDKGO72+ILAgpWFcwLpmK+OJS4dcyKYhlk4RweVIpAWcI6BGTt34TRUYa4Knb3OFI0qPvwsiz2HOygNQ9IaBfYgl8cHj9ePbLUc+nx12MoYriJmvDZQKXHW+BzkZimw70TiVoMeOGECA2D+dC0kEgYqhTSlVTG7DxlxymDB2RNyBz1WmKuCyeyCz+9Pwcjig9IwRAgosAdxNezZagXkMknYyhiuIoarTpEwDPSaDL6+PFHjUqtkUKsCs0e1SpayHPvuQ0Y8V38AZ0/IxZUXTh70eGFuBvwsi25L8tstxAulYYgQUGAP4vrEZAeD9viCzMEz9mBFTGgKQpOtRG8C+8bYXB4+qAOAWiWHIwXljlxQP2tCDmp/MC9smqIgmHPvStN0DJeGKT6L0jAkvUUV2BsaGlBZWYmKigps2rRp0OMHDhzA8uXLcdVVV+GOO+6A2Zx+lRGhM3YgsMelscfBV8aEVsSE0mQp0WN1J2xcdqcXapWcv61WyZKeiokmqAOBVAyAtM2zf2u0otviwnkztakeCiGjEjGwGwwG1NXVYfPmzaivr8eWLVtw7NixfsesX78ea9aswVtvvYVp06bhhRdeSNiAE4XrE8OlWQZWxoRWxITKzVLA5fElLD1ic3qQGTpjV8qTukAp2qAOAPnZKjBI38DOfdKgjTVIuosY2Jubm1FaWgqNRgO1Wo3FixejsbGx3zF+vx82WyBt4XA4oFKpwj3VmDZoxs5VxgTTMXxFzIA/ek1WoAQxUW18B87YMxKcYzeZnThlsOCUwYKP97ZGHdQBQC6TQJOtTNuSR1Pw2kB+Tvr9/hISKmIi0Wg0Qqvt+2iq0+mwd+/efsfcd999uOWWW/CrX/0KGRkZ2Lp1a/xHmmAWuxsKmQRKhRQAoM9XQy6T4KOvWnHeTG1fRczAwJ4ZeCPosboxriD+Mz2bY8CMPYGpmJ372vDi218jtNvL9Im5UQV1TkGuKm1z7CaLE1IJw19nISRdRfxrDdfUKfTiodPpxIMPPog///nPKCkpwUsvvYS1a9fi+eefj3oQBQUjb7Sk1WZHPigKbh8LTbay3/Pd9YN5+O3fvsBzbx2EJkeJbLUCZ0/J73/+wco+v0QSt7FwWDbQorcwT80/d6ZKDpfbF/fvtWP3Kby4/WuUzCjE0ounAQCkUgnmzdBCKZdG/TwTddk42GKK+/ji/XzhONx+FGoyoNflRD44CZJxzmMNnXN8RAzser0eu3fv5m8bjUbodH01vkeOHIFSqURJSQkAYOXKlfjd734X0yC6uqzw+2PvCqjVZqOjwxLz14XT0W2HWinr93zFU/KwunIOP4udOUmDzs7+2+axnsDs+XRrLzomDa7tHg2X2wevjwXDsvy4MlQy2J1eGI3mQQuERoqbqc+Zmoc7rzqnXyA39wy/m9RAWSopOrsdaDf0QiqJT9FVPF/n4bR2WJGrlifle0WSrHMeS+icoyeRMMNOiCP+5ZWVlWHXrl0wmUxwOBxoampCeXk5//iUKVPQ3t6O48ePAwD+8Y9/oLi4OOaBpprF7kFOMK0S6uLicVi9dA4YAJO0g3+QKoUUCrkkITl2mzOQ91cPuHjKAnDGqa2AsduOF7cHgvrPlpfENDsPJ51r2bstTsqvE0GIasZeW1uL6upqeDwerFixAiUlJaipqcGaNWtQXFyMxx9/HD//+c/BsiwKCgrwq1/9KhljjyuL3Y2JQ1RDXFw8DuMLM/lyvlAMwwRLHuMfyLgeNFkDyh2BQGCPR631wZZusCxw0/dnjTqoA/1r2QtzM0b9fMnCvRnlZStTPRRCRi2qyFBVVYWqqqp+923cuJH//2WXXYbLLrssviNLIpZl+c6OQ5k2bui8qyZTkZBa9nAz9sxgkHe4vHEJQodOdUOTpYAuLz5BOLSWfVZcnjE5rHYPvD6WZuxEEGjlKUL6xGSOrBoiUatPuRl75oByRyA+uyixLIvDp3owe3Je3PL16VrLbrIExkszdiIEFNgBmLka9oyhZ+zD4VafxntbOFswsKsHlDsC8enJ3m6yo9fm5jfJiId0rWXvNnM17BTYSfqjwI6+VacjrV/mVp/G64Imxx5MxWQO6BUDRL893nBvNoeCm0/Pnpw3whGGl4617NzipLxsSsWQ9EeBHX2rTsNVxUQjUatPbU4vGAAqZWhVTPQz9lMGC+7+/Sf49EB72McPxzm/zknHvuy0OIkICQV2ABZbcMaeMcIce8jq03gKtBOQQRKS/1YHxxjNLkr7T5hgdXiwcdvBQcGdZVkcinN+nZOOfdm7zYGKGEmcfxaEpAIFdgAWR/8+MbHSZCdoxj6gZS8AvsQxmhl7S7sF+TlKzJqkGRTc2012mOOcX+ekYy27yeJCPl04JQJBgR3BPjHyvj4xseJSMb0JmbH3/xQhlTBQyqVRBfaT7WacNS4Hd6+YNyi4Jyq/DqRnX3ZanESEhAI7ALPNM+KKGCBxq08HNgDjv59SCmeEckerw4OOHiemFGVDqZD2C+67DrQnLL8OpF9fdlqcRISGAjsAi8ONnBHWsAOJW31qCzNjBwIXUCPtonTSEOg/MTW4sCo0uP9p20F8eawzIfl1IP1q2WlxEhEaCuxAxFWn0UjETkp25xAzdkXknuwn2wOBfYq+r3NcaHB3e/wJya8DfbXsxu70qGWnxUlEaGhjRwzfJyZamiwFWtrj15mOZdngjH3wS5ShlEZcedrSbkFhrgpZAyp9lAop7v7BPPzroAEXnaOP23gHmlqUjW9aexP2/PFEi5OI0Ih+xs73iRlhDTtHk6VEbxxXn7o9fvj8bL92ApwMhSziAqWWNjOmFoXv86yUS1E+bzzkstE3/RrKrMl5MHY7YDKP/XQMLU4iQiP6wH6m0waP14+cUaZi4r36NFwDME6GcvhdlKwODzp7nXx+PRVmB9M8h0/3pGwM0TJZnJBJaXESEQ5RB/YznTY89coXyM1U4PxZo9uZPt6rT8O17OWolMOXO3IXTqcMMWNPhom6LGSqZDh8qjtlY4hWt9kFTRYtTiLCIdrAfqbThic3fw6GYfCLVQtQqBld2V9fYI/PBdRhZ+zBVIx/iLRPuAunySZhGMycpOHr5ccyk8VFFTFEUEQZ2B0uL5585Qs+qMdjE2pNFtdWIL4z9rA5dqUMLAJb54XT0maGVjP4wmmypUue3WR20qpTIiiiDOwn2sww29z40ZWz4xLUgfivPg3XspejUgYueg6Vz29pt2BKUeo3ZE6HPLufZdFjpcVJRFhEGdi5VMXZE+K3+XS8V5+Ga9nL4To82sPk2fkLpynMr3PSIc9uocVJRIBEGdiHqvEeDW71abwaX4Vr2ctRKYL7noYJ7MdbzQBSe+GUk8g8+95vOvGbLV+i1za6T0jdtDiJCJAoA/vJdktCAl9+tpJfxTha4Vr2cjKCqZhwJY/v7T6NrAw5psfx08hoJCrP/sXRTuw/YcKTr3wxquDOpbxSfT2CkHgSXWC3OT0w9jgSkqoozM2IW38Um3Nwy15OBj9j759jP/ZtLw6cMOHK0slQyhO3+CgWicqzG7sd0GQp0NnrGFVw5y5Aj5WfFyHxEFVgb2hoQGVlJSoqKrBp06Z+j3399de4+uqr+X+XXnopli1blpDBxgOXX5+agIuLhbkq9Frd8HhHv0hpqAZgQF9P9oE59vqdJ5CVIccVCyaO+vvHC5dnP9hiGtHX7zlsxMb6fYPuN3TbMWdKHn6+Yh46ex34zZYvhyz/HA4X2FUjbNlMyFgUMbAbDAbU1dVh8+bNqK+vx5YtW3Ds2DH+8Tlz5qC+vh719fX429/+htzcXDzyyCOJHPOo8DXeCZix833IzaPPsw/VAAzoS8WE5tj7zdbHUJCSMAzOm6nFZ18bR3Rh+cOvWrHt4+P93izdHh9MZhf0eWrMnpKHqy+ZhtNGK2zBDVNi4fIEZ+xj6GdGyGhFDOzNzc0oLS2FRqOBWq3G4sWL0djYGPbYP/7xj1i4cCHOP//8uA80Xk4k4MIpp68P+ei7Gg43Y+cunoZujzcWZ+ucpWVT4fOx2P7pyZi+jmVZtLRZ4GeBti47f39HT+Dnq8sPLCrLDfb5CVclFImTUjFEgCIGdqPRCK22b7m9TqeDwWAYdJzZbMbWrVtx1113xXeEcXay3ZywipHC3ECgiUeefbgZu2TALkrfnBmbs3WOTpOBsuIifPBFa0xVQyazC9bgLLy108bfbwi2A9bnqQEAamXgDZBb1BULfsZOgZ0ISMS2veG6FYbbnKGhoQHf+973UFBQEPMgCgqyYv4ajlYbfZC22t3o6HHiyrJpMX1dtPLzMyGVMHB4/KN6fpZlYXd5UZinDvs8Wm02MjNkYBkGWm02Xv3wOJQKKX5QMZvPv481Ny87B8372/HB3jbcfk1xVF9zLKQNco/Dy/8sbPsD2/vNna5FllqB8ZbAhVOFSh7zz10qk0Ihl0KvT/2CroES8Ts61tE5x0fEKKDX67F7927+ttFohE6nG3Tc+++/jzvuuGNEg+jqssLvj/3Cl1abjY6O6HugcxfwtNnKmL4uFnnZSpxqM4/q+V1uH7w+FgzLDnoe7pyVcim6zU4YDGbs/OoMSs4qgNXsgHW0J5AgUgBl5xbhneYWXF4yLqq68b1HjJAwDArzMnD0pIn/WRz/tgdZGXI4bC44bC64HYHA3mawYEKMW/119zqgkEkS9vswUrH+bgsBnXP0JBJm2AlxxFRMWVkZdu3aBZPJBIfDgaamJpSXl/c7hmVZHDhwAAsWLIh5gMnUksALp5zCXNWIcuz7T3Th9Y+OAxi+ARhHpZDB6fLi8OkemO0eLJw9+M12rFlWNhUsG32uvaXNgvGFmZg+Mbd/KsZkhz4kgHM/p5Hm2KkihghNxMCu1+tRW1uL6upqXHPNNVi2bBlKSkpQU1ODffsCZWgmkwlyuRxK5dhevZeIFacDjbSWvXl/O7Y1t+Dwqe5hW/ZyuF2U/n3ICIVcguKzY0+BJZtOk4Gyc4vw4ZeRc+0sy6Kl3YKp47IxWZ8DY4+Dr4wx9jigC+bXgZDyzxHk2N0e35i8LkHIaESVkK2qqkJVVVW/+zZu3Mj/v6CgADt37ozvyBLgZPvQuwrFS6Gmr5Y9lh2KzMEFNm/tbMFVF08FMPyMPUMhQ7fFhc8PGzHv7MK0ufi3tGwqmve3451PT2JVxcwhj+MunE4tysZ4fTbYYGVMUb46WOrYN2NXKaRgGMDuir3c0enxpc3PjpBoiWblqc3pQUePM+E9VApHWMtutrkhlTD4+mQ3vjzWCSB8y15OhlKGti572qRhONys/YMBs/bm/W345+ff8rdb2vt63kwO9pVv7bTBOKDUEQhczFcrZSOrinFTYCfCI5rAbgoGWn3IR/hE6Ct5jC3P3mtz48K5euRmKvD+7kCAGzbHHlyklC5pmFBLg7n2d4K59vd2n8aftn2Nl987gnZToF69pd0CCcNgkjYL47VZkEoYtHbZYBxQ6shRq2QjyrG7aMZOBEg0gT1ZKwz7FilFn2f3+f2w2j0ozFXhytIp8AUrhIaqYwf6+sWkUxqGEzprf/2j43jl/aMoObsAcpkEDTtbAARWCE/QZkIhl0Iuk0CXl4EzHTYYugOBXz+g+kWtlI94xk4XT4nQiCawu4OBXSFL7ClrspSQShh0xRDYrXYPWAA5mQpcPn88cjMVQ7bs5XAXDNMpDROKm7Vva27BeTO1uOvaYlyxYCI+PdiOdpM9uFlIX9psfGEmWjttMJgcyMqQD1qVO9IZu5MunhIBEk1gT9aMXSJhkJ+jjGnGznUmzFEroJBLccP3ZuCic4uG3Vx51mQN5p1dkHZpGI5Ok4FrLp2GyxdMwJ1XnwOZVIIlF06GXCrBXxoP8RdOORMKM2HsceBMp3XQbB0IbD7iGOHK03T7xENIJGNzmWICJHPpeKDkMfocO1cRkxvcN/WCOXpcMEc/7NdMG5eDu38wb+SDHAOWXjS13+2cTAWuOG8iGj87BQCDZuwsG9hIpHRu0aDnyhjBjJ1lWbjp4ikRINHM2N0ePwBAEUMJ4kgV5KpGNmMPNrMSsyUXToZCJoFUErhwyplQGNiblmUH59eBwIydW9gVLbfXDxbUspcIj/hm7En4Iw7tyx5NLbvZ3peKEbucTAX+o/wstHbaoAiZSevz1ZBKGPj8bL9SR45aJYPb44fX54dMGt18hevFrqAZOxEY0QR2N5+KSfyHlNBa9qL8yOWVvVY3FHIJzRyDFl8wedB9MmmgMqatyx62ZDV0g+9o3yCdHtpkgwiTaFIxLo8fDBD1bG40Yq1lN9vdyFErwnbNJH24dEzYVEywNDSWC6hu6sVOBEpUM3aFQpqU4BlrLbvZ5uY3iyBDO2+mFm6vP+wGJNx9sVxAddLuSUSgRBPYk1nWFmste6/NDZ0mtnazYlR6ThFKzxlcEQOEpGJimLHTRtZEqESTinF7fAlfnMSJtZadZuyjN5LWvS7KsROBEk1gd3n8Sf3IXZibwfc1GQ7XToBKHUenb8YefckjzdiJUIkosCd3IYo+LwPGbnvE4ywh7QTIyI1kxk45diJUognsyUzFAIAuTw2b08tvxjwUftUpBfZRUcqlkDAM5dgJgYgCeypm7AAipmPMtOo0LhiGibkRWDLbTBCSTCIK7MnNseuCC5MMEdIx1E4gfmJtBOZyBz7FSSS0foAIi2gCeyAVk8TArlGBweAZe7vJjhNtZv622UbtBOIl1kZgLo+P2gkQQRJVYE/mR265TIr8HOWgGfumpsN45vV9YNnAZhq9NmonEC+xbo/npE02iECJJrC7PD4oFMk9XV2eGgZT34ydZVmcaLOg2+LiZ/LUTiB+RpJjp4oYIkSiCOw+vx9eHwtlElMxwOCSx44eBx94Dp3qBhBoAEYVMfERmLHHUMdOm2wQgYoqsDc0NKCyshIVFRXYtGnToMePHz+Om266CVdddRVuvfVW9Pb2xn2go8H3Yk/yH/HAkseWdgsAQMIwOHyqB0Bwxk6BPS5inrHTJhtEoCIGdoPBgLq6OmzevBn19fXYsmULjh07xj/Osix+/OMfo6amBm+99RbmzJmD559/PqGDjlUye7GHGljyeLLdApmUwfwZhTh0qhssy1I7gThSK/t6skfD5aEcOxGmiIG9ubkZpaWl0Gg0UKvVWLx4MRobG/nHDxw4ALVajfLycgDAnXfeiRtvvDFxIx6BZPZiDzWw5LGl3YIJ2iycMy0fPVY32rrs1E4gjmLt8EgzdiJUEbs7Go1GaLVa/rZOp8PevXv526dOnUJhYSHWrl2LgwcPYubMmXjooYdiGkRBQVbkg4ag1WZHPMYaTMUUFmRFdXy85GrUYBjA5vKhsDALp4xWXDJvPMrmT8Bf3z2Mg6d7wQIYr8+JaVzJPIexIppz1ge30stQK6HVRv6dcvv8yM1Rjdmf51gdVyLROcdHxMDOleWFCq3g8Hq9+Oyzz/Dyyy+juLgYv/3tb/HEE0/giSeeiHoQXV1W+P2Dv08kWm02OjosEY9rNwaOcTncUR0fT/nZShw/04ODR42wOTzQa1RQgEVupgIf7DkNAJCy/qjHFe05C0m05+x1B2bq37b1Qo7Iv08OlxesL/qffTLR6ywOIz1niYQZdkIcMTeh1+vR2dnJ3zYajdDpdCED02LKlCkoLi4GACxbtqzfjH4scKdw6ThX8shdOJ1WlAOGYTBrsgatnTYAtOo0XmLpye5nWbgpFUMEKmJgLysrw65du2AymeBwONDU1MTn0wFgwYIFMJlMOHToEABgx44dOOeccxI34hHgLp4qkpxjB/pKHrkLpxO0ge3dZk/O44+hwB4fsXR49Hj8YEG92IkwRUzF6PV61NbWorq6Gh6PBytWrEBJSQlqamqwZs0aFBcX43/+53+wbt06OBwOFBUV4de//nUyxh61VDZ74koeD7SYMEGbxe+5Omuyhj+GqmLiI5ae7KmqlCIkGaLaGq+qqgpVVVX97tu4cSP//3nz5uG1116L78jiiKtjT0Vg1+cHSh5PGay4bP54/v6ifDVyMxVwuL1QKUSzQ2FCxTJjd1JnRyJgolh52peKSc2MnTOlqO/qN8MwKD67APqQx8noxNKTnXqxEyETxVQxVXXsQF+XRxaBC6ehbqyYCY83usU0JLJYerLTfqdEyEQzY2cY8PntZOK6PIZeOOUo5VJkZciTPiYhi7YnOzdjp7a9RIhEMmP3QyGXpqyD4iRdNvKcnpS8sYhNtD3ZnW6asRPhEkVgT3UXv9VL58AfZqEXib9oe7Kncm0DIYkmiilkILCn7lSzMuS0Q1KSRJtjd1K5IxEwUQR2LhVDhC/anuxUFUOETBSBPdWpGJI8sVbF0O8FESIK7ERQou3J7nL7oJBJIJHQloREeEQR2N2ewB8xET6uJ7stwgVUJ+13SgRMFNHO5fHTH7FIaLICF6l7LK5hj6NNNoiQiSKwuz0+ungqEvk5KgCAyeIc9jgXzdiJgIkmsCtl9EcsBnnZSgBAd6QZu8cHFb3ZE4ESRWB3eXxQKERxqqKXk6mAVMLAZI6ciqFPcUSoBB/tfH4/vD6W8qkiIWEYaLKU6I6QinG6fdROgAiW4AM714tdQakY0cjPUUacsbspx04ETPCBnXbKEZ+8bGXEHLuT1jYQARNPYE9hrxiSXPk5KpgsLrDDNF6jckciZIKPdpSKEZ+8bCW8Pj8sjvA9Y/wsC7eHcuxEuAQf2CkVIz752YFa9u4h8uwejx8sqE8MES7xBHb6IxaN/JxALftQi5SoZS8RuqgCe0NDAyorK1FRUYFNmzYNevyZZ57BokWLcPXVV+Pqq68Oe0wi7TrQjv985hOYzIP/kN38RtaCfw8jQZEWKdGbPRG6iDsoGQwG1NXV4fXXX4dCocD111+PCy+8ENOnT+eP2b9/P37zm99gwYIFCR1sOLv2t+NPbx8EywIGk51fUs6hP2LxibRIiXqxE6GLOI1tbm5GaWkpNBoN1Go1Fi9ejMbGxn7H7N+/Hxs3bkRVVRUee+wxuFzDl5rFyz/3nMaf3j4InSYDAML24eYuntIfsXhEWqTkov1OicBFDOxGoxFarZa/rdPpYDAY+Ns2mw1z5szB2rVr8cYbb8BsNuPZZ59NzGhDtHba8NtXPsesSRrctbwEAMLudeny0G70YjTcIiWnO/B7Qr8TRKgipmLC1QIzTN/mBJmZmdi4cSN/e/Xq1XjggQdQW1sb9SAKCrKiPpaTlZOBmmuK8b2Fk+HzB8YokUuh1Wb3O06uCJzihHG5gvlDHniOYhDrOY8rzMLR0z1hv673oBEAMHe6FnkDUndjCb3O4pCIc44Y2PV6PXbv3s3fNhqN0Ol0/O3W1lY0NzdjxYoVAAJvBDJZxKftp6vLCr9/6MUkQ1l2yVno6LDAz7JgABg7bejosPQ7xtRjB8MAPd22fm9I6UqrzR50jkI3knNWK6Xo6HHAaDQPet0PfNMRqHV3edDREXl/1FSg11kcRnrOEgkz7IQ4YiqmrKwMu3btgslkgsPhQFNTE8rLy/nHVSoVnnzySZw+fRosy2LTpk2oqKiIeaCjIWEYZCjD73Xp9vihlEsFEdRJ9IZbpHSy3YIpevHNDIl4RAzser0etbW1qK6uxjXXXINly5ahpKQENTU12LdvH/Lz8/HYY4/hxz/+MZYsWQKWZXHLLbckY+z9qFWyIXPsQknBkOgNtUjJ4fKivcuOqUUU2IlwRZUzqaqqQlVVVb/7QvPqixcvxuLFi+M7shiplTI4wszYAxtZUw272IQuUpoSEsRPG61ggX73ESI0gol4gRn74I/d1OxJnPKDi5QGVsa0tJkBgGbsRNAEE9iHzLF7/ZSKEaHs4CKlgatPWwwW5GUrkZulTNHICEk8wQR2tSp8YHdR321RkjBMsC97/0VKdOGUiIFwArtSHvbiqZtSMaKVl91/kRJdOCViIZzArpLB6fbB5/f3u9/l9VMDMJHKz1H1S8WcMljAApg6jgI7ETbBRDy1MlDg43D5+t3vpnJH0crLVvbbSelke2AhyJSinFQOi5CEE05gVwUC+8A8O1XFiFd+cJGSodsBIOTCaaYixSMjJLGEE9i5GfuAPLvb66NUjEgVn1WADKUMdVu/RFevky6cEtEQTMTjZ+whtew+vx9eH0szdpHS56txz8r5sDq82LD5c7pwSkRDMIE9Qzk4FeNyUy92sTtrfA7uWTkfNqeXLpwS0RBMYO+bsfcFdreXerGTQHD/r+vno3zeeMyalJfq4RCScLH11x3D1Eo5gAEzdn5bPMG8f5ERmjYuB9PGUTUMEQfBRDyVUgoG/WfstLclIUSMBBPYw/VktwV7catV8lQNixBCkk4wgR0Y3JPdFFx1yLVwJYQQMRBcYA/tyc4H9mwK7IQQ8RBWYFf278nebXYiK0MOuYxy7IQQ8RBWYFfJ++XYTRYXzdYJIaIjrMA+4OKpyexCfo4qhSMihJDkE1ZgH3DxtNviRB7N2AkhIiOYBUpAYMbO9WT3+ljYnF6qiCGEiI6gAnuGqq8nuzVYw04zdkKI2ESVimloaEBlZSUqKiqwadOmIY/74IMPcMUVV8RtcLFShzQC6zYH9rrMz6YcOyFEXCLO2A0GA+rq6vD6669DoVDg+uuvx4UXXojp06f3O66zsxMbNmxI2ECjwTUCczi9fA17HqViCCEiE3HG3tzcjNLSUmg0GqjVaixevBiNjY2Djlu3bh3uuuuuhAwyWvyM3emhxUmEENGKOGM3Go3QarX8bZ1Oh7179/Y75i9/+Qvmzp2LefPmjWgQBQVZI/o6ANBq+/prWz2B/usypRwOjx85mQqMH6cZ8XOPVaHnLBZ0zuJA5xwfEQM7txFwKIZh+P8fOXIETU1N+L//+z+0t7ePaBBdXVb4/YO/TyRabTY6Oiz8bZfdDQBoN1rQarRAk6Xo97gQDDxnMaBzFgc65+hJJMywE+KIqRi9Xo/Ozk7+ttFohE6n4283Njaio6MDy5cvx+233w6j0YhVq1bFPNB4CN3Q2mR20YVTQogoRQzsZWVl2LVrF0wmExwOB5qamlBeXs4/vmbNGrz77ruor6/H888/D51Oh82bNyd00ENRKqRgmEBP9m6Lky6cEkJEKaoZe21tLaqrq3HNNddg2bJlKCkpQU1NDfbt25eMMUZNwjBQK2XosboCi5PowikhRISiWqBUVVWFqqqqfvdt3Lhx0HETJ07Ejh074jOyEcpQynCm0waAatgJIeIkqF4xQCDPfqYjENhp1SkhRIyEF9iVMn4Ta+oTQwgRI+EF9pD9TWnGTggRI+EF9uDqU9o5iRAiVsIL7MFadkrDEELESniBPThjp4oYQohYCS6wcz3ZaXESIUSsBBfY+2bsFNgJIeIkvMCuolQMIUTcBBfYdZoMMAwwQZuZ6qEQQkhKCGrPUwCYoM3CH+4u52fuhBAiNoKbsQOgoE4IETVBBnZCCBEzCuyEECIwFNgJIURgKLATQojAUGAnhBCBocBOCCECMybqAiUSJiVfm67onMWBzlkcRnLOkb6GYVmWHemACCGEjD2UiiGEEIGhwE4IIQJDgZ0QQgSGAjshhAgMBXZCCBEYCuyEECIwFNgJIURgKLATQojAUGAnhBCBSdvA3tDQgMrKSlRUVGDTpk2pHk5CPPPMM1i6dCmWLl2KX//61wCA5uZmVFVV4fvf/z7q6upSPMLE2bBhA+677z4AwNdff43ly5dj8eLFePDBB+H1elM8uvjasWMHrr32WixZsgS//OUvAQj/da6vr+d/tzds2ABAuK+z1WrFsmXL8O233wIY+rWN6/mzaai9vZ1dtGgR293dzdpsNraqqoo9evRoqocVVzt37mRXrlzJulwu1u12s9XV1WxDQwN72WWXsadOnWI9Hg+7evVq9oMPPkj1UOOuubmZvfDCC9m1a9eyLMuyS5cuZb/44guWZVn2/vvvZzdt2pTC0cXXqVOn2EsuuYRta2tj3W43e8MNN7AffPCBoF9nu93OLly4kO3q6mI9Hg+7YsUKdufOnYJ8nb/88kt22bJl7DnnnMOePn2adTgcQ7628Tz/tJyxNzc3o7S0FBqNBmq1GosXL0ZjY2OqhxVXWq0W9913HxQKBeRyOc4++2y0tLRgypQpmDRpEmQyGaqqqgR33j09Pairq8Odd94JADhz5gycTifmz58PALj22msFdc7vvfceKisrUVRUBLlcjrq6OmRkZAj6dfb5fPD7/XA4HPB6vfB6vZDJZIJ8nbdu3YqHH34YOp0OALB3796wr228f8/HRHfHWBmNRmi1Wv62TqfD3r17Uzii+JsxYwb//5aWFmzfvh033XTToPM2GAypGF7C/Pd//zdqa2vR1tYGYPBrrdVqBXXOJ0+ehFwux6233oqOjg4sWrQIM2bMEPTrnJWVhbvvvhtXXnklVCoVLrjgAsjlckG+zuvXr+93O1zsMhgMcf89T8sZOxumISXDCLPd59GjR7F69WqsXbsWkydPHvS4kM771Vdfxbhx43DRRRfx9wn9tfb5fNi1axeefPJJbN26Ffv27eNzsaGEdM6HDh3C3//+d/zzn//EJ598AolEgp07dw46TkjnzBnq9znev+dpOWPX6/XYvXs3f9toNPIfdYRkz549WLNmDR544AEsXboUn332GTo7O/nHhXbe27dvR0dHB66++mr09vbCbreDYZh+59zR0SGocy4sLMRFF12E/Px8AMB3v/tdNDY2QiqV8scI7XX+5JNPcNFFF6GgoABAIO3wwgsvCPp15uj1+rB/wwPvH+35p+WMvaysDLt27YLJZILD4UBTUxPKy8tTPay4amtrw09/+lM89dRTWLp0KQBg3rx5OHHiBE6ePAmfz4dt27YJ6rxfeuklbNu2DfX19VizZg2uuOIKPP7441AqldizZw8A4M033xTUOS9atAiffPIJzGYzfD4fPv74YyxZskTQr/Ps2bPR3NwMu90OlmWxY8cOXHDBBYJ+nTlD/Q1PmDAhrueftjP22tpaVFdXw+PxYMWKFSgpKUn1sOLqhRdegMvlwhNPPMHfd/311+OJJ57Az372M7hcLlx22WVYsmRJCkeZHE899RTWrVsHm82GuXPnorq6OtVDipt58+bhtttuw6pVq+DxeHDxxRfjhhtuwFlnnSXY1/mSSy7BwYMHce2110Iul6O4uBi33347KioqBPs6c5RK5ZB/w/H8PacdlAghRGDSMhVDCCFkaBTYCSFEYCiwE0KIwFBgJ4QQgaHATgghAkOBnZAhrF69GiaTKdXDICRmFNgJGUK4Ze6EpAMK7ISEcf/99wMAbr75Zr4hGSHpghYoETKEWbNmYdeuXXwfF0LSBc3YCSFEYCiwE0KIwFBgJ2QIUqlUMPtuEnGhwE7IECoqKrBq1SocOXIk1UMhJCZ08ZQQQgSGZuyEECIwFNgJIURgKLATQojAUGAnhBCBocBOCCECQ4GdEEIEhgI7IYQIDAV2QggRmP8PeV/DRh075JMAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -214,7 +249,7 @@ } ], "source": [ - "ax = results.variables.SupportModel.plot()" + "ax = results.variables.SupportModel.plot()\n" ] }, { @@ -222,29 +257,33 @@ "id": "dying-bundle", "metadata": {}, "source": [ - "## A multi-run experiment" + "## A multi-run experiment\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "amino-sustainability", "metadata": {}, "outputs": [], "source": [ + "# (sheridan) here we're now keeping the initial support constant at an average of 0.5 (where the previous model showed approximately\n", + "# a 50% chance of success) and varying the popular_agent_support_multiplier - i.e. how much more or less the popular agents support \n", + "# the cause compared to the average\n", "sample_parameters = {\n", - " 'steps': 100,\n", - " 'n_agents': 100,\n", - " 'n_friends': 2,\n", - " 'network_randomness': 0.5,\n", - " 'initial_support': ap.Range(0, 1),\n", - " 'random_encounters': 1\n", - "}" + " \"steps\": 100,\n", + " \"n_agents\": 100,\n", + " \"n_friends\": 2,\n", + " \"network_randomness\": 0.5,\n", + " \"initial_support\": 0.5,\n", + " \"popular_agent_support_multiplier\": ap.Range(0, 4),\n", + " \"random_encounters\": 1,\n", + "}\n" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "opening-pottery", "metadata": {}, "outputs": [ @@ -252,17 +291,39 @@ "name": "stdout", "output_type": "stream", "text": [ - "Scheduled runs: 2500\n", - "Completed: 2500, estimated time remaining: 0:00:00\n", + "Scheduled runs: 2500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n", + "[Parallel(n_jobs=4)]: Done 42 tasks | elapsed: 7.0s\n", + "[Parallel(n_jobs=4)]: Done 192 tasks | elapsed: 13.1s\n", + "[Parallel(n_jobs=4)]: Done 442 tasks | elapsed: 26.9s\n", + "[Parallel(n_jobs=4)]: Done 792 tasks | elapsed: 45.5s\n", + "[Parallel(n_jobs=4)]: Done 1242 tasks | elapsed: 1.1min\n", + "[Parallel(n_jobs=4)]: Done 1792 tasks | elapsed: 1.5min\n", + "[Parallel(n_jobs=4)]: Done 2442 tasks | elapsed: 2.0min\n", + "[Parallel(n_jobs=4)]: Done 2500 out of 2500 | elapsed: 2.1min finished\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Experiment finished\n", - "Run time: 0:04:05.299086\n" + "Run time: 0:02:04.737254\n" ] } ], "source": [ "sample = ap.Sample(sample_parameters, n=50)\n", "exp = ap.Experiment(SupportModel, sample, iterations=50)\n", - "results = exp.run()" + "# (sheridan) add parallel processing as the experiments now all take longer. use half of available cores.\n", + "cores_for_exp = int(os.cpu_count() / 2)\n", + "results = exp.run(n_jobs=cores_for_exp, verbose=1)\n" ] }, { @@ -273,7 +334,17 @@ "outputs": [ { "data": { - "image/png": "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\n", + "text/plain": [ + "Text(0, 0.5, 'Chances of success')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -284,12 +355,10 @@ ], "source": [ "ax = sns.lineplot(\n", - " data=results.arrange_reporters(),\n", - " x='initial_support',\n", - " y='success'\n", + " data=results.arrange_reporters(), x=\"popular_agent_support_multiplier\", y=\"success\"\n", ")\n", - "ax.set_xlabel('Initial share of supporters')\n", - "ax.set_ylabel('Chances of success');" + "ax.set_xlabel(\"Popular Agent Support Multiplier\")\n", + "ax.set_ylabel(\"Chances of success\")\n" ] }, { @@ -297,26 +366,125 @@ "id": "timely-transparency", "metadata": {}, "source": [ - "## Questions for discussion" + "## Analysis of outcome\n", + "We can see from the multi-run experiment that the `popular_agent_support_boost` factor does indeed have a proportional impact on chance of success, up until a cap of about 2.0 support boost. This is expected, as at this level we are taking the initial support level (0.5) and multiplying it by 2, so the support level in the popular agents is 100% and you can't increase beyond that level. In the appendix below we run the experiment again just between 0 and 2 to zoom in on that effect, and add a trend line to the data to show this relationship even more clearly.\n", + "\n", + "Additionally the model shows that if the popular agents have less support than the `initial_support` level, the changes of success drop down below the expectation, which also follows what we might expect.\n", + "\n", + "This model suggests that it might be important to target the people with a lot of connections in a network, as their impact will be outsized on the support propagating to other members of the network.\n" ] }, { "cell_type": "markdown", - "id": "homeless-arrest", + "id": "8801fb42", + "metadata": {}, + "source": [ + "## Appendix\n", + "Here I re-run the multi-run experiment with a `popular_agent_support_multiplier` range of 0 to 2, and add a trend line to more clearly show the relationship between this measure of popular agents' support levels and success." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "92a620b7", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scheduled runs: 2500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n", + "[Parallel(n_jobs=4)]: Done 42 tasks | elapsed: 2.2s\n", + "[Parallel(n_jobs=4)]: Done 192 tasks | elapsed: 9.0s\n", + "[Parallel(n_jobs=4)]: Done 442 tasks | elapsed: 20.5s\n", + "[Parallel(n_jobs=4)]: Done 792 tasks | elapsed: 36.1s\n", + "[Parallel(n_jobs=4)]: Done 1242 tasks | elapsed: 56.2s\n", + "[Parallel(n_jobs=4)]: Done 1792 tasks | elapsed: 1.4min\n", + "[Parallel(n_jobs=4)]: Done 2442 tasks | elapsed: 1.9min\n", + "[Parallel(n_jobs=4)]: Done 2500 out of 2500 | elapsed: 2.0min finished\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Experiment finished\n", + "Run time: 0:02:00.577981\n" + ] + } + ], "source": [ - "- What happens under different parameter values?\n", - "- How does this model compare to real-world dynamics?\n", - "- What false conclusions could be made from this model?\n", - "- How could the model be improved or extended?" + "sample_parameters_smaller_window = {\n", + " \"steps\": 100,\n", + " \"n_agents\": 100,\n", + " \"n_friends\": 2,\n", + " \"network_randomness\": 0.5,\n", + " \"initial_support\": 0.5,\n", + " \"popular_agent_support_multiplier\": ap.Range(0, 2),\n", + " \"random_encounters\": 1,\n", + "}\n", + "sample_smaller_window = ap.Sample(sample_parameters_smaller_window, n=50)\n", + "exp_smaller_window = ap.Experiment(SupportModel, sample_smaller_window, iterations=50)\n", + "# add parallel processing as the experiments now all take longer. use half of available cores.\n", + "cores_for_exp = int(os.cpu_count() / 2)\n", + "results_smaller_window = exp_smaller_window.run(n_jobs=cores_for_exp, verbose=1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "bccd05ab", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Chances of success')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = results_smaller_window.arrange_reporters()\n", + "grouped_data = (\n", + " df[[\"popular_agent_support_multiplier\", \"success\"]]\n", + " .groupby(\"popular_agent_support_multiplier\")\n", + " .mean()\n", + ")\n", + "ax = sns.regplot(data=grouped_data, x=grouped_data.index, y=\"success\")\n", + "ax.set_xlabel(\"Popular Agent Support Multiplier\")\n", + "ax.set_ylabel(\"Chances of success\")\n" ] } ], "metadata": { + "interpreter": { + "hash": "5fff94e99599e721866a571c2f4cac93c8b1dbb1388f11031306f18ec80cb629" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "venv", "language": "python", - "name": "python3" + "name": "venv" }, "language_info": { "codemirror_mode": { @@ -328,7 +496,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.7.4" } }, "nbformat": 4, From f6df138ae1edfdc289d5e04171c175347b3522b3 Mon Sep 17 00:00:00 2001 From: Sheridan Kates Date: Fri, 3 Jun 2022 14:56:28 +0100 Subject: [PATCH 3/5] Fix links and code inside html --- 05_Social_Support_ABM.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/05_Social_Support_ABM.ipynb b/05_Social_Support_ABM.ipynb index ba37ecf..38c1997 100644 --- a/05_Social_Support_ABM.ipynb +++ b/05_Social_Support_ABM.ipynb @@ -21,7 +21,7 @@ "id": "actual-warren", "metadata": {}, "source": [ - "[This notebook by Joël Foramitti](https://github.com/JoelForamitti/ses_modeling_course/blob/main/05_Social_Support_ABM.ipynb) introduced a simple agent-based model to explore the propagation of social support through a population. The purpose of this notebook is to try to adapt it to model the effect of different levels of support among the popular agents in the model (i.e. those with more than average friend connections), to model how that might affect successful outcomes of support for a cause. Edits from the original code are called out in comments marked `(sheridan)`, and additions to the text are in bold italics (like this one).\n" + "This notebook by Joël Foramitti introduced a simple agent-based model to explore the propagation of social support through a population. The purpose of this notebook is to try to adapt it to model the effect of different levels of support among the popular agents in the model (i.e. those with more than average friend connections), to model how that might affect successful outcomes of support for a cause. Edits from the original code are called out in comments marked (sheridan), and additions to the text are in bold italics (like this one).\n" ] }, { @@ -84,7 +84,7 @@ "source": [ "At the start of the simulation, the model initiates a population of agents, defines a random network of friendships between these agents, and chooses a random share of agents to be the initial supporters of the cause.\n", "\n", - "The major change in the model logic is here. Instead of assigning the support randomly across all agents in the model, we now use the `popular_agent_support_multiplier` to alter now much support there is among the popular agents (i.e. those with the most connections) for the cause, while still ensuring the same amount of support for the cause overall.\n", + "The major change in the model logic is here. Instead of assigning the support randomly across all agents in the model, we now use the popular_agent_support_multiplier to alter now much support there is among the popular agents (i.e. those with the most connections) for the cause, while still ensuring the same amount of support for the cause overall.\n", "\n", "At every simulation step, agents change their support and the share of supporters is recorded.\n", "\n", @@ -367,11 +367,11 @@ "metadata": {}, "source": [ "## Analysis of outcome\n", - "We can see from the multi-run experiment that the `popular_agent_support_boost` factor does indeed have a proportional impact on chance of success, up until a cap of about 2.0 support boost. This is expected, as at this level we are taking the initial support level (0.5) and multiplying it by 2, so the support level in the popular agents is 100% and you can't increase beyond that level. In the appendix below we run the experiment again just between 0 and 2 to zoom in on that effect, and add a trend line to the data to show this relationship even more clearly.\n", + "We can see from the multi-run experiment that the popular_agent_support_boost factor does indeed have a proportional impact on chance of success, up until a cap of about 2.0 support boost. This is expected, as at this level we are taking the initial support level (0.5) and multiplying it by 2, so the support level in the popular agents is 100% and you can't increase beyond that level. In the appendix below we run the experiment again just between 0 and 2 to zoom in on that effect, and add a trend line to the data to show this relationship even more clearly.\n", "\n", - "Additionally the model shows that if the popular agents have less support than the `initial_support` level, the changes of success drop down below the expectation, which also follows what we might expect.\n", + "Additionally the model shows that if the popular agents have less support than the initial_support level, the changes of success drop down below the expectation, which also follows what we might expect.\n", "\n", - "This model suggests that it might be important to target the people with a lot of connections in a network, as their impact will be outsized on the support propagating to other members of the network.\n" + "This model suggests that it might be important to target the people with a lot of connections in a network, as their impact will be outsized on the support propagating to other members of the network." ] }, { @@ -380,7 +380,7 @@ "metadata": {}, "source": [ "## Appendix\n", - "Here I re-run the multi-run experiment with a `popular_agent_support_multiplier` range of 0 to 2, and add a trend line to more clearly show the relationship between this measure of popular agents' support levels and success." + "Here I re-run the multi-run experiment with a popular_agent_support_multiplier range of 0 to 2, and add a trend line to more clearly show the relationship between this measure of popular agents' support levels and success." ] }, { From 31cb6e4baedcd17f6d904e8691c19a769d7a9450 Mon Sep 17 00:00:00 2001 From: Sheridan Kates Date: Fri, 3 Jun 2022 15:04:26 +0100 Subject: [PATCH 4/5] Fix title --- 05_Social_Support_ABM.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/05_Social_Support_ABM.ipynb b/05_Social_Support_ABM.ipynb index 38c1997..52158f2 100644 --- a/05_Social_Support_ABM.ipynb +++ b/05_Social_Support_ABM.ipynb @@ -5,7 +5,7 @@ "id": "static-collection", "metadata": {}, "source": [ - "# Weighting of friends in agent-based models of social support\n" + "# Impact of well-connected agents in agent-based models of social support\n" ] }, { From 62278cd59ef5ca1dbd7271b478adcb76611ec4c6 Mon Sep 17 00:00:00 2001 From: Sheridan Kates Date: Thu, 9 Jun 2022 18:20:15 +0100 Subject: [PATCH 5/5] Fix typo --- 05_Social_Support_ABM.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/05_Social_Support_ABM.ipynb b/05_Social_Support_ABM.ipynb index 52158f2..eede004 100644 --- a/05_Social_Support_ABM.ipynb +++ b/05_Social_Support_ABM.ipynb @@ -84,7 +84,7 @@ "source": [ "At the start of the simulation, the model initiates a population of agents, defines a random network of friendships between these agents, and chooses a random share of agents to be the initial supporters of the cause.\n", "\n", - "The major change in the model logic is here. Instead of assigning the support randomly across all agents in the model, we now use the popular_agent_support_multiplier to alter now much support there is among the popular agents (i.e. those with the most connections) for the cause, while still ensuring the same amount of support for the cause overall.\n", + "The major change in the model logic is here. Instead of assigning the support randomly across all agents in the model, we now use the popular_agent_support_multiplier to alter how much support there is among the popular agents (i.e. those with the most connections) for the cause, while still ensuring the same amount of support for the cause overall.\n", "\n", "At every simulation step, agents change their support and the share of supporters is recorded.\n", "\n",