From 55f8f6ac2817ae93df89f510a53bd2323f117d76 Mon Sep 17 00:00:00 2001 From: Tom Pike Date: Wed, 16 Oct 2024 06:27:37 -0400 Subject: [PATCH 1/6] intro_tutorial Update intro tutorial for Mesa 3.0 --- docs/howto.md | 39 + docs/tutorials/intro_tutorial.ipynb | 834 ++++++++++++++++---- docs/tutorials/visualization_tutorial.ipynb | 88 ++- 3 files changed, 785 insertions(+), 176 deletions(-) diff --git a/docs/howto.md b/docs/howto.md index 7fbb08e3576..f7da02e2055 100644 --- a/docs/howto.md +++ b/docs/howto.md @@ -2,6 +2,45 @@ This guide provides concise instructions and examples to help you start with common tasks in Mesa. +## Implementing Different Activation Regimes + + +### Random Activation + +self.agents.shuffle_do("") + +### Random Activation By Type + +```python +for agent_class in self.agent_types: + self.agents_by_type[agent_class].shuffle_do("") +``` +### Only Activating Certain Agent Types + +```python +self.agents_by_type[AgentType].shuffle_do("") +``` + +### Staged Activation + +```python +for stage in ["stage1", "stage2", "stage3"]: + self.agents.do(stage) +``` + +If you want to `shuffle` and/or `shuffle_between_stages` options: +```python + +stages = ["stage1", "stage2", "stage3"] +if shuffle: + self.random.shuffle(stages) +for stage in stages: + if shuffle_between_stages: + self.agents.shuffle_do(stage) + else: + self.agents.do(stage) +``` + ## Models with Discrete Time For models involving agents of multiple types, including those with a time attribute, you can construct a discrete-time model. This setup allows each agent to perform actions in steps that correspond to the model's discrete time. diff --git a/docs/tutorials/intro_tutorial.ipynb b/docs/tutorials/intro_tutorial.ipynb index 77630fe3c68..f6071e06de1 100644 --- a/docs/tutorials/intro_tutorial.ipynb +++ b/docs/tutorials/intro_tutorial.ipynb @@ -15,11 +15,11 @@ "source": [ "**Important:** \n", "- If you are just exploring Mesa and want the fastest way to execute the code we recommend executing this tutorial online in a Colab notebook. [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/projectmesa/mesa/blob/main/docs/tutorials/intro_tutorial.ipynb)\n", - "- If you have installed mesa and are running locally, please ensure that your [Mesa version](https://pypi.org/project/Mesa/) is up-to-date in order to run this tutorial.\n", + "- If you have installed mesa and are running locally, please ensure that your Mexa version is greater than or equal to 3.0.0b1.\n", "\n", "## Tutorial Description\n", "\n", - "[Mesa](https://github.com/projectmesa/mesa) is a Python framework for [agent-based modeling](https://en.wikipedia.org/wiki/Agent-based_model). This tutorial will assist you in getting started. Working through the tutorial will help you discover the core features of Mesa. Through the tutorial, you are walked through creating a starter-level model. Functionality is added progressively as the process unfolds. Should anyone find any errors, bugs, have a suggestion, or just are looking for clarification, [let us know](https://github.com/projectmesa/mesa/issues)!\n", + "[Mesa](https://github.com/projectmesa/mesa) is a Python framework for [agent-based modeling](https://en.wikipedia.org/wiki/Agent-based_model). This tutorial will assist you in getting started. Working through the tutorial will help you discover the core features of Mesa. Through the tutorial, you will walk through a starter-level model. Functionality is added progressively as the process unfolds. Should anyone find any errors, bugs, have a suggestion, or just are looking for clarification, let us know in our [chat](https://matrix.to/#/#project-mesa:matrix.org)!\n", "\n", "The premise of this tutorial is to create a starter-level model representing agents exchanging money. This exchange of money affects wealth. \n", "\n", @@ -38,7 +38,7 @@ "source": [ "## Model Description\n", "\n", - "This is a starter-level simulated agent-based economy. In an agent-based economy, the behavior of an individual economic agent, such as a consumer or producer, is studied in a market environment.\n", + "This is a simulated agent-based economy. In an agent-based economy, the behavior of an individual economic agent, such as a consumer or producer, is studied in a market environment.\n", "This model is drawn from the field econophysics, specifically a paper prepared by Drăgulescu et al. for additional information on the modeling assumptions used in this model. [Drăgulescu, 2002].\n", "\n", "The assumption that govern this model are:\n", @@ -48,8 +48,9 @@ "3. At every step of the model, an agent gives 1 unit of money (if they\n", " have it) to some other agent.\n", "\n", - "Even as a starter-level model the yielded results are both interesting and unexpected to individuals unfamiliar\n", - "with it the specific topic. As such, this model is a good starting point to examine Mesa's core features." + "Even as a starter-level model it yields results that are both interesting and unexpected. \n", + "\n", + "Due to its simplicity and intrquiging results, we found ti to be a greater starter model. " ] }, { @@ -96,8 +97,9 @@ "source": [ "# SKIP THIS CELL unless running in colab\n", "\n", - "%pip install --quiet mesa\n", - "# The exclamation points tell jupyter to do the command via the command line" + "%pip install --quiet --upgrade --pre mesa\n", + "print(f\"Mesa version: {mesa.__version__}\")\n", + "# The percent sign installs in the process associated with the notebook" ] }, { @@ -106,25 +108,16 @@ "source": [ "## Building the Sample Model\n", "\n", - "After Mesa is installed a model can be built. A jupyter notebook is recommended for this tutorial, this allows for small segments of codes to be examined one at a time. As an option this can be created using python script files.\n", - "\n", - "**Good Practice:** Place a model in its own folder/directory. This is not specifically required for the starter_model, but as other models become more complicated and expand multiple python scripts, documentation, discussions and notebooks may be added.\n", - "\n", - "### Create New Folder/Directory\n", - "\n", - "- Using operating system commands create a new folder/directory named 'starter_model'.\n", - "\n", - "- Change into the new folder/directory.\n", - "\n", + "After Mesa is installed a model can be built. A jupyter notebook is recommended for this tutorial, this allows for small segments of codes to be examined one at a time. \n", "\n", "### Creating Model With Jupyter Notebook\n", "\n", - "Write the model interactively in [Jupyter Notebook](http://jupyter.org/) cells.\n", + "Write the model interactively in [Jupyter](http://jupyter.org/) cells.\n", "\n", - "Start Jupyter Notebook:\n", + "Start Jupyter:\n", "\n", "```bash\n", - "jupyter notebook\n", + "jupyter lab\n", "```\n", "\n", "Create a new Notebook named `money_model.ipynb` (or whatever you want to call it).\n", @@ -133,7 +126,9 @@ "\n", "Create a new file called `money_model.py` (or whatever you want to call it)\n", "\n", - "*Code will be added as the tutorial progresses.*\n" + "*Code will be added as the tutorial progresses.*\n", + "\n", + "**Good Practice:** Place a model in its own folder/directory. This is not specifically required for the starter_model, but as other models become more complicated and expand multiple python scripts, documentation, discussions and notebooks may be added." ] }, { @@ -146,9 +141,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "outputs": [], "source": [ @@ -173,22 +171,19 @@ "\n", "First create the agent. As the tutorial progresses, more functionality will be added to the agent.\n", "\n", - "**Background:** Agents are the individual entities that act in the model. It is a good modeling practice to make certain each Agent can be uniquely identified.\n", - "\n", - "**Model-specific information:** Agents are the individuals that exchange money, in this case the amount of money an individual agent has is represented as wealth. Additionally, agents each have a unique identifier.\n", + "**Background:** Agents are the individual entities that act in the model. Mesa automatically assigns each agent that is created an integer as a `unique_id.` \n", "\n", - "**Code implementation:** This is done by creating a new class (or object) that extends `mesa.Agent` creating a subclass of the `Agent` class from mesa. The new class is named `MoneyAgent`. The technical details about the agent object can be found in the [mesa repo](https://github.com/projectmesa/mesa/blob/main/mesa/agent.py).\n", + "**Model-specific information:** Agents are the individuals that exchange money, in this case the amount of money an individual agent has is represented as wealth. \n", "\n", + "**Code implementation:** This is done by creating a new class (or object) that extends `mesa.Agent` creating a subclass of the `Agent` class from mesa. The new class is named `MoneyAgent`. The inherited code of the Mesa agent object can be found in the [mesa repo](https://github.com/projectmesa/mesa/blob/main/mesa/agent.py).\n", "\n", - "The `MoneyAgent` class is created with the following code:\n" + "The `MoneyAgent` class is created with the following code:" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 44, + "metadata": {}, "outputs": [], "source": [ "class MoneyAgent(mesa.Agent):\n", @@ -208,20 +203,20 @@ "source": [ "### Create Model\n", "\n", - "Next, create the model. Again, as the tutorial progresses, more functionality will be added to the model.\n", + "Next, create the model. This gives us the two basic classess of any Mesa ABM - the agent class (population of agent objects that doing something) and the manager class (a model object that manages the creation, activation, datacollection etc of the agents)\n", "\n", - "**Background:** The model can be visualized as a grid containing all the agents. The model creates, holds and manages all the agents on the grid. The model evolves in discrete time steps.\n", + "**Background:** The model can be visualized as a list containing all the agents. The model creates, holds and manages all the agent objects, specifically in a dictionary. The model activates agents in discrete time steps.\n", "\n", - "**Model-specific information:** When a model is created the number of agents within the model is specified. The model then creates the agents and places them on the grid. The model also contains a scheduler which controls the order in which agents are activated. The scheduler is also responsible for advancing the model by one step. The model also contains a data collector which collects data from the model. These topics will be covered in more detail later in the tutorial.\n", + "**Model-specific information:** When a model is created the number of agents within the model is specified. The model then creates the agents and places them in an set of agents. \n", "\n", - "**Code implementation:** This is done by creating a new class (or object) that extends `mesa.Model` and calls `super().__init__()`, creating a subclass of the `Model` class from mesa. The new class is named `MoneyModel`. The technical details about the agent object can be found in the [mesa repo](https://github.com/projectmesa/mesa/blob/main/mesa/model.py).\n", + "**Code implementation:** This is done by creating a new class (or object) that extends `mesa.Model` and calls `super().__init__()`, creating a subclass of the `Model` class from mesa. The new class is named `MoneyModel`. The technical details about the model object can be found in [model module](https://github.com/projectmesa/mesa/blob/main/mesa/model.py) and the AgentSet in the [agent module](https://github.com/projectmesa/mesa/blob/d7a3834c99a3be809abe2edc8b83610f3d4438ba/mesa/agent.py#L86).\n", "\n", "The `MoneyModel` class is created with the following code:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -237,24 +232,24 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "### Adding the Scheduler\n", - "Now the model will be modified to add a scheduler.\n", + "### Making the Agents `do`\n", "\n", - "**Background:** The scheduler controls the order in which agents are activated, causing the agent to take their defined action. The scheduler is also responsible for advancing the model by one step. A step is the smallest unit of time in the model, and is often referred to as a tick. The scheduler can be configured to activate agents in different orders. This can be important as the order in which agents are activated can impact the results of the model [Comer2014]. At each step of the model, one or more of the agents -- usually all of them -- are activated and take their own step, changing internally and/or interacting with one another or the environment.\n", + "With the basics of the Agent class and Model class created we can no activate the agents to `do` things\n", "\n", - "**Model-specific information:** A new class is named `RandomActivationByAgent` is created which extends `mesa.time.RandomActivation` creating a subclass of the `RandomActivation` class from Mesa. This class activates all the agents once per step, in random order. Every agent is expected to have a ``step`` method. The step method is the action the agent takes when it is activated by the model schedule. We add an agent to the schedule using the `add` method; when we call the schedule's `step` method, the model shuffles the order of the agents, then activates and executes each agent's ```step``` method. The scheduler is then added to the model.\n", + "**Background:** Mesa's `do` function calls agent functions the grow your ABM. A step is the smallest unit of time in the model, and is often referred to as a tick. The `do` function and Python functionality can be configured to activate agents in different orders. This can be important as the order in which agents are activated can impact the results of the model [Comer2014]. At each step of the model, one or more of the agents -- usually all of them -- are activated and take their own step, changing internally and/or interacting with one another or the environment. A overview of different ways to employ the `do` function for different activation regimes can be found in the [\"How To\" Guide](https://mesa.readthedocs.io/latest/howto.html).\n", "\n", - "**Code implementation:** The technical details about the timer object can be found in the [mesa repo](https://github.com/projectmesa/mesa/blob/main/mesa/time.py). Mesa offers a few different built-in scheduler classes, with a common interface. That makes it easy to change the activation regime a given model uses, and see whether it changes the model behavior. The details pertaining to the scheduler interface can be located in the same [mesa repo](https://github.com/projectmesa/mesa/blob/main/mesa/time.py).\n", + "**Model-specific information:** For this section we wil randomly reorder the Agent activation order using `mesa.Agent.shuffle_do` and have the agents `step` function print the agent unique id they are assigned during the agent creation process. \n", "\n", - "With that in mind, the `MoneyAgent` code is modified below to visually show when a new agent is created. The MoneyModel code is modified by adding the RandomActivation method to the model. with the scheduler added looks like this:" + "**Code implementation:** Using standard ABM convention we add a `step` function to the `MoneyModel` class which calls the `mesa.Agent.shuffle_do` function. We then pass into `shuffle_do` the parameter \"step\". This tells mesa to look for and execute the `step` function in our MoneyAgent class. " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -280,20 +275,17 @@ " def __init__(self, N):\n", " super().__init__()\n", " self.num_agents = N\n", - " # Create scheduler and assign it to the model\n", - " self.schedule = mesa.time.RandomActivation(self)\n", - "\n", + " \n", " # Create agents\n", " for _ in range(self.num_agents):\n", - " a = MoneyAgent(self)\n", - " # Add the agent to the scheduler\n", - " self.schedule.add(a)\n", + " a = MoneyAgent(self) # This calls the agent class parameter N number of times \n", "\n", " def step(self):\n", " \"\"\"Advance the model by one step.\"\"\"\n", "\n", - " # The model's step will go here for now this will call the step method of each agent and print the agent's unique_id\n", - " self.schedule.step()" + " # This function psuedo-randomly reorders the list of agent objects and then iterates through calling the function passed in as the parameter\n", + " # In this case we use the ABM convention step but it could be any function in the Agent class\n", + " self.agents.shuffle_do(\"step\")" ] }, { @@ -318,9 +310,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hi, I am an agent, you can call me 2.\n", + "Hi, I am an agent, you can call me 5.\n", + "Hi, I am an agent, you can call me 8.\n", + "Hi, I am an agent, you can call me 9.\n", + "Hi, I am an agent, you can call me 1.\n", + "Hi, I am an agent, you can call me 6.\n", + "Hi, I am an agent, you can call me 10.\n", + "Hi, I am an agent, you can call me 4.\n", + "Hi, I am an agent, you can call me 3.\n", + "Hi, I am an agent, you can call me 7.\n" + ] + } + ], "source": [ "starter_model = MoneyModel(10)\n", "starter_model.step()" @@ -328,13 +337,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "outputs": [], - "source": [ - "# Run this step overnight and see what happens! Notice the order of the agents changes each time.\n", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hi, I am an agent, you can call me 2.\n", + "Hi, I am an agent, you can call me 4.\n", + "Hi, I am an agent, you can call me 8.\n", + "Hi, I am an agent, you can call me 3.\n", + "Hi, I am an agent, you can call me 9.\n", + "Hi, I am an agent, you can call me 5.\n", + "Hi, I am an agent, you can call me 7.\n", + "Hi, I am an agent, you can call me 1.\n", + "Hi, I am an agent, you can call me 6.\n", + "Hi, I am an agent, you can call me 10.\n" + ] + } + ], + "source": [ + "# Run this step a few times and see what happens! Notice the order of the agents changes each time.\n", "starter_model.step()" ] }, @@ -348,9 +377,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "outputs": [], "source": [ @@ -381,7 +413,10 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "outputs": [], "source": [ @@ -414,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -434,7 +469,7 @@ " def step(self):\n", " # Verify agent has some wealth\n", " if self.wealth > 0:\n", - " other_agent = self.random.choice(self.model.schedule.agents)\n", + " other_agent = self.random.choice(self.model.agents)\n", " if other_agent is not None:\n", " other_agent.wealth += 1\n", " self.wealth -= 1" @@ -459,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -477,11 +512,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "agent_wealth = [a.wealth for a in model.schedule.agents]\n", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "agent_wealth = [a.wealth for a in model.agents]\n", "# Create a histogram with seaborn\n", "g = sns.histplot(agent_wealth, discrete=True)\n", "g.set(\n", @@ -505,9 +551,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHFCAYAAAAUpjivAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABCLElEQVR4nO3de1RVdf7/8deROwgkIhwY0chrBWpqmVgC3oq8ZpOWaVZO2XhJvGSpU2G/EsfGS2k6Y8vUcoxWk1p2UdEEM7OUdES0tLwXxGgIggSK+/dHy/PtiJpHD2zcPh9r7bXan/05e78/J1e++uzP3sdmGIYhAAAAi6pldgEAAABVibADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADXCX+85//yGaz6d133610rGXLlrLZbFq9enWlY40aNVLr1q2rpKZFixbJZrPpwIEDjralS5dq1qxZlfoeOHBANptN//jHP6q8hoSEBCUkJLh0nl27diklJcXpPJfi3GtV1TinTJmiFStWVGrPyMiQzWZTRkaGW68HWAlhB7hKJCQkyGazaf369U7tv/zyi7KzsxUQEFDp2JEjR7Rv3z4lJiZWW50XCjvVae7cuZo7d65Ln9m1a5cmT57scti5nGtdjguFndatW+vLL7+sskALWIGn2QUAuDShoaGKiYmp9H/wmZmZ8vT01JAhQyqFnbP71Rl2aoKbbrqpyq9x8uRJ+fv7V8u1LiYoKEi33367qTUANR0zO8BVJDExUd99951yc3MdbRkZGbr11lt1zz33KCsrSydOnHA65uHhoTvvvFOSZBiG5s6dq1atWsnPz0916tTRn//8Z+3bt8/pOunp6erdu7fq168vX19fNW7cWEOHDtXRo0cvWl9CQoI+/vhjHTx4UDabzbGda8aMGYqOjlbt2rXVvn17bd68+ZLGv3nzZnXo0EG+vr6KjIzUhAkTdOrUqfPWce5trHnz5qlly5aqXbu2AgMD1bx5c02cOFHSb7fC7r//fkm/fcdn6160aJHjfDExMdqwYYPi4uLk7++vxx577ILXkqQzZ87o5ZdfVoMGDeTr66u2bdtq3bp1Tn0eeeQRXX/99ZU+m5KS4vS92Ww2lZSUaPHixY7azl7zQrexPvzwQ7Vv317+/v4KDAxU165d9eWXX573Ojk5OXrwwQcVHBys8PBwPfbYYyosLKxUF3C1IuwAV5GzMzS//4tt/fr1io+PV4cOHWSz2fT55587HWvdurWCg4MlSUOHDlVycrK6dOmiFStWaO7cucrJyVFcXJx+/vlnx+d++OEHtW/fXvPmzdOaNWv0/PPP66uvvtIdd9xx3nBx1ty5c9WhQwfZ7XZ9+eWXju33Xn/9daWnp2vWrFn697//rZKSEt1zzz1/+Jfrrl271LlzZx0/flyLFi3SP//5T23btk0vvfTSH35vaWlpGjZsmOLj47V8+XKtWLFCo0ePVklJiSSpe/fumjJliqO+s3V3797dcY7c3FwNHDhQAwYM0CeffKJhw4Zd9Jpz5szRqlWrNGvWLC1ZskS1atVSUlJSpe/jUnz55Zfy8/PTPffc46jtYrfOli5dqt69eysoKEjvvPOOFixYoIKCAiUkJGjjxo2V+t93331q2rSp3n//fT377LNaunSpRo8e7XKdQI1lALhq/PLLL0atWrWMJ554wjAMwzh69Khhs9mMVatWGYZhGLfddpsxbtw4wzAM49ChQ4YkY/z48YZhGMaXX35pSDKmT5/udM7Dhw8bfn5+jn7nOnPmjHHq1Cnj4MGDhiTjgw8+cBxbuHChIcnYv3+/o6179+5Gw4YNK51n//79hiQjNjbWOH36tKP966+/NiQZ77zzzkXH3r9/f8PPz8/Iy8tztJ0+fdpo3rx5pRri4+ON+Ph4x/6IESOM66677qLnf++99wxJxvr16ysdi4+PNyQZ69atO++x31/r7DgjIyON0tJSR3tRUZEREhJidOnSxdE2ePDg835XL7zwgnHuf54DAgKMwYMHV+q7fv16p7orKiqMyMhIIzY21qioqHD0O3HihBEWFmbExcVVus60adOczjls2DDD19fXOHPmTKXrAVcjZnaAq0idOnXUsmVLx8xOZmamPDw81KFDB0lSfHy8Y53Ouet1PvroI9lsNg0cOFCnT592bHa73emckpSfn68nn3xSUVFR8vT0lJeXlxo2bChJ2r179xWNoXv37vLw8HDst2jRQpJ08ODBi35u/fr16ty5s8LDwx1tHh4e6t+//x9e87bbbtPx48f14IMP6oMPPvjD23HnU6dOHXXq1OmS+/ft21e+vr6O/cDAQPXs2VMbNmxQRUWFy9e/VN99951++uknDRo0SLVq/d9/4mvXrq377rtPmzdv1smTJ50+06tXL6f9Fi1a6Ndff1V+fn6V1QlUJ8IOcJVJTEzUnj179NNPP2n9+vVq06aNateuLem3sLNt2zYVFhZq/fr18vT01B133CFJ+vnnn2UYhsLDw+Xl5eW0bd682REAzpw5o27dumnZsmUaP3681q1bp6+//tqxrqa0tPSK6q9bt67Tvo+PzyWd99ixY7Lb7ZXaz9d2rkGDBunNN9/UwYMHdd999yksLEzt2rVTenr6JdcdERFxyX0vVJfdbld5ebmKi4tdOpcrjh07Jun89UZGRurMmTMqKChwar/cfyfA1YKnsYCrTGJiombMmKGMjAxlZGTonnvucRw7G2w2bNjgWLh8NgiFhoY61vSc/cvs98627dy5U//973+1aNEiDR482HH8+++/r8ph/aG6desqLy+vUvv52s7n0Ucf1aOPPqqSkhJt2LBBL7zwgnr06KE9e/Y4Zq0u5nwLrS/mQrV6e3s7/p34+vqqrKysUr/LmXk662xw+f0i9rN++ukn1apVS3Xq1Lns8wNXI2Z2gKtMx44d5eHhof/85z/KyclxehIoODhYrVq10uLFi3XgwAGnR8579OghwzD0448/qm3btpW22NhYSf/3l/q5gehf//rXJdXn4+NTJTMCiYmJWrdundNC6oqKivO+ZPFiAgIClJSUpEmTJqm8vFw5OTmS3D+bsWzZMv3666+O/RMnTmjlypW68847Hbfxrr/+euXn5zuNqby8/Lwvh7zU77VZs2b605/+pKVLl8owDEd7SUmJ3n//fccTWsC1hJkd4CoTFBSk1q1ba8WKFapVq5Zjvc5Z8fHxjpf6/T7sdOjQQU888YQeffRRbd26VR07dlRAQIByc3O1ceNGxcbG6q9//auaN2+uRo0a6dlnn5VhGAoJCdHKlSsv+ZZPbGysli1bpnnz5qlNmzaqVauW2rZte8Xj/tvf/qYPP/xQnTp10vPPPy9/f3+9/vrrjieqLubxxx+Xn5+fOnTooIiICOXl5Sk1NVXBwcG69dZbJUkxMTGSpPnz5yswMFC+vr6Kjo6udIvnUnl4eKhr164aM2aMzpw5o7///e8qKirS5MmTHX369++v559/Xg888ICefvpp/frrr3rttdfOu6YnNjZWGRkZWrlypSIiIhQYGKhmzZpV6lerVi1NmzZNDz30kHr06KGhQ4eqrKxMr7zyio4fP66pU6de1niAqxkzO8BVKDExUYZh6JZbblFQUJDTsfj4eBmGIW9vb8XFxTkd+9e//qU5c+Zow4YNeuCBB9S9e3c9//zzKikp0W233SZJ8vLy0sqVK9W0aVMNHTpUDz74oPLz87V27dpLqm3UqFH685//rIkTJ+r22293hIkrFRMTo7Vr1yooKEiDBw/WE088oRYtWui55577w8/eeeed2rlzp0aNGqWuXbtq9OjRatq0qT7//HPVq1dPkhQdHa1Zs2bpv//9rxISEnTrrbdq5cqVl13viBEj1LVrVz311FMaMGCATp8+rY8//tgpnEZHR+uDDz7Q8ePH9ec//1lPP/207r//fj388MOVzvfqq6+qSZMmeuCBB3Trrbdq6NChF7z2gAEDtGLFCh07dkz9+/fXo48+qqCgIK1fv95xqxO4ltiM389zAgAAWAwzOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNJ4qaB++y2gn376SYGBgS6/Eh4AAJjDMAydOHFCkZGRTj98ey7Cjn77vZioqCizywAAAJfh8OHDql+//gWPE3YkBQYGSvrtyzr3bbQAAKBmKioqUlRUlOPv8Qsh7Oj/fvgwKCiIsAMAwFXmj5agsEAZAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYmqfZBVjdoUOHdPToUbPLMFVoaKgaNGhgdhkAgGsUYacKHTp0SM2b36jS0pNml2IqPz9/ffvtbgIPAMAUhJ0qdPToUZWWnlS7x15QUMT1ZpdjiqLcA/rqzck6evQoYQcAYArCTjUIirheIQ2amV0GAADXJBYoAwAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAAS6sxYSc1NVU2m03JycmONsMwlJKSosjISPn5+SkhIUE5OTlOnysrK9PIkSMVGhqqgIAA9erVS0eOHKnm6gEAQE1VI8LOli1bNH/+fLVo0cKpfdq0aZoxY4bmzJmjLVu2yG63q2vXrjpx4oSjT3JyspYvX660tDRt3LhRxcXF6tGjhyoqKqp7GAAAoAYyPewUFxfroYce0htvvKE6deo42g3D0KxZszRp0iT17dtXMTExWrx4sU6ePKmlS5dKkgoLC7VgwQJNnz5dXbp00S233KIlS5YoOztba9euNWtIAACgBjE97AwfPlzdu3dXly5dnNr379+vvLw8devWzdHm4+Oj+Ph4bdq0SZKUlZWlU6dOOfWJjIxUTEyMo8/5lJWVqaioyGkDAADWZOrPRaSlpembb77Rli1bKh3Ly8uTJIWHhzu1h4eH6+DBg44+3t7eTjNCZ/uc/fz5pKamavLkyVdaPgAAuAqYNrNz+PBhjRo1SkuWLJGvr+8F+9lsNqd9wzAqtZ3rj/pMmDBBhYWFju3w4cOuFQ8AAK4apoWdrKws5efnq02bNvL09JSnp6cyMzP12muvydPT0zGjc+4MTX5+vuOY3W5XeXm5CgoKLtjnfHx8fBQUFOS0AQAAazIt7HTu3FnZ2dnavn27Y2vbtq0eeughbd++XTfccIPsdrvS09MdnykvL1dmZqbi4uIkSW3atJGXl5dTn9zcXO3cudPRBwAAXNtMW7MTGBiomJgYp7aAgADVrVvX0Z6cnKwpU6aoSZMmatKkiaZMmSJ/f38NGDBAkhQcHKwhQ4Zo7Nixqlu3rkJCQjRu3DjFxsZWWvAMAACuTaYuUP4j48ePV2lpqYYNG6aCggK1a9dOa9asUWBgoKPPzJkz5enpqX79+qm0tFSdO3fWokWL5OHhYWLlAACgpqhRYScjI8Np32azKSUlRSkpKRf8jK+vr2bPnq3Zs2dXbXEAAOCqZPp7dgAAAKoSYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFiaqWFn3rx5atGihYKCghQUFKT27dvr008/dRx/5JFHZLPZnLbbb7/d6RxlZWUaOXKkQkNDFRAQoF69eunIkSPVPRQAAFBDmRp26tevr6lTp2rr1q3aunWrOnXqpN69eysnJ8fR5+6771Zubq5j++STT5zOkZycrOXLlystLU0bN25UcXGxevTooYqKiuoeDgAAqIE8zbx4z549nfZffvllzZs3T5s3b9bNN98sSfLx8ZHdbj/v5wsLC7VgwQK9/fbb6tKliyRpyZIlioqK0tq1a3XXXXdV7QAAAECNV2PW7FRUVCgtLU0lJSVq3769oz0jI0NhYWFq2rSpHn/8ceXn5zuOZWVl6dSpU+rWrZujLTIyUjExMdq0aVO11g8AAGomU2d2JCk7O1vt27fXr7/+qtq1a2v58uW66aabJElJSUm6//771bBhQ+3fv1/PPfecOnXqpKysLPn4+CgvL0/e3t6qU6eO0znDw8OVl5d3wWuWlZWprKzMsV9UVFQ1gwMAAKYzPew0a9ZM27dv1/Hjx/X+++9r8ODByszM1E033aT+/fs7+sXExKht27Zq2LChPv74Y/Xt2/eC5zQMQzab7YLHU1NTNXnyZLeOAwAA1Eym38by9vZW48aN1bZtW6Wmpqply5Z69dVXz9s3IiJCDRs21N69eyVJdrtd5eXlKigocOqXn5+v8PDwC15zwoQJKiwsdGyHDx9234AAAECNYnrYOZdhGE63mH7v2LFjOnz4sCIiIiRJbdq0kZeXl9LT0x19cnNztXPnTsXFxV3wGj4+Po7H3c9uAADAmky9jTVx4kQlJSUpKipKJ06cUFpamjIyMrRq1SoVFxcrJSVF9913nyIiInTgwAFNnDhRoaGhuvfeeyVJwcHBGjJkiMaOHau6desqJCRE48aNU2xsrOPpLAAAcG0zNez8/PPPGjRokHJzcxUcHKwWLVpo1apV6tq1q0pLS5Wdna233npLx48fV0REhBITE/Xuu+8qMDDQcY6ZM2fK09NT/fr1U2lpqTp37qxFixbJw8PDxJEBAICawtSws2DBggse8/Pz0+rVq//wHL6+vpo9e7Zmz57tztIAAIBF1Lg1OwAAAO5E2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJbmaXYBuDbs3r3b7BJMExoaqgYNGphdBgBcswg7qFKlhcck2TRw4ECzSzGNn5+/vv12N4EHAExC2EGVOnXyhCRDrQY8o3rRzc0up9oV5R7QV29O1tGjRwk7AGASwg6qRe2wBgpp0MzsMgAA1yAWKAMAAEszNezMmzdPLVq0UFBQkIKCgtS+fXt9+umnjuOGYSglJUWRkZHy8/NTQkKCcnJynM5RVlamkSNHKjQ0VAEBAerVq5eOHDlS3UMBAAA1lKlhp379+po6daq2bt2qrVu3qlOnTurdu7cj0EybNk0zZszQnDlztGXLFtntdnXt2lUnTpxwnCM5OVnLly9XWlqaNm7cqOLiYvXo0UMVFRVmDQsAANQgpoadnj176p577lHTpk3VtGlTvfzyy6pdu7Y2b94swzA0a9YsTZo0SX379lVMTIwWL16skydPaunSpZKkwsJCLViwQNOnT1eXLl10yy23aMmSJcrOztbatWvNHBoAAKghasyanYqKCqWlpamkpETt27fX/v37lZeXp27dujn6+Pj4KD4+Xps2bZIkZWVl6dSpU059IiMjFRMT4+hzPmVlZSoqKnLaAACANZkedrKzs1W7dm35+PjoySef1PLly3XTTTcpLy9PkhQeHu7UPzw83HEsLy9P3t7eqlOnzgX7nE9qaqqCg4MdW1RUlJtHBQAAagrTw06zZs20fft2bd68WX/96181ePBg7dq1y3HcZrM59TcMo1Lbuf6oz4QJE1RYWOjYDh8+fGWDAAAANZbpYcfb21uNGzdW27ZtlZqaqpYtW+rVV1+V3W6XpEozNPn5+Y7ZHrvdrvLychUUFFywz/n4+Pg4ngA7uwEAAGsyPeycyzAMlZWVKTo6Wna7Xenp6Y5j5eXlyszMVFxcnCSpTZs28vLycuqTm5urnTt3OvoAAIBrm6lvUJ44caKSkpIUFRWlEydOKC0tTRkZGVq1apVsNpuSk5M1ZcoUNWnSRE2aNNGUKVPk7++vAQMGSJKCg4M1ZMgQjR07VnXr1lVISIjGjRun2NhYdenSxcyhAQCAGsLUsPPzzz9r0KBBys3NVXBwsFq0aKFVq1apa9eukqTx48ertLRUw4YNU0FBgdq1a6c1a9YoMDDQcY6ZM2fK09NT/fr1U2lpqTp37qxFixbJw8PDrGEBAIAaxNSws2DBgoset9lsSklJUUpKygX7+Pr6avbs2Zo9e7abqwMAAFZQ49bsAAAAuJPLYeebb75Rdna2Y/+DDz5Qnz59NHHiRJWXl7u1OAAAgCvlctgZOnSo9uzZI0nat2+fHnjgAfn7++u9997T+PHj3V4gAADAlXA57OzZs0etWrWSJL333nvq2LGjli5dqkWLFun99993d30AAABXxOWwYxiGzpw5I0lau3at7rnnHklSVFSUjh496t7qAAAArpDLYadt27Z66aWX9PbbbyszM1Pdu3eXJO3fv/+iby0GAAAwg8thZ+bMmfrmm280YsQITZo0SY0bN5Yk/ec//+GtxQAAoMZx+T07LVu2dHoa66xXXnlFnp6mvrYHAACgEpdndm644QYdO3asUvuvv/6qpk2buqUoAAAAd3E57Bw4cEAVFRWV2svKynTkyBG3FAUAAOAul3zf6cMPP3T88+rVqxUcHOzYr6io0Lp16xQdHe3e6gAAAK7QJYedPn36SPrt96oGDx7sdMzLy0vXX3+9pk+f7tbiAAAArtQlh52z79aJjo7Wli1bFBoaWmVFAQAAuIvLj0/t37+/KuoAAACoEpf1rPi6deu0bt065efnO2Z8znrzzTfdUhgAAIA7uBx2Jk+erBdffFFt27ZVRESEbDZbVdQFAADgFi6HnX/+859atGiRBg0aVBX1AAAAuJXL79kpLy/nZyEAAMBVw+Ww85e//EVLly6tiloAAADczuXbWL/++qvmz5+vtWvXqkWLFvLy8nI6PmPGDLcVBwAAcKVcDjs7duxQq1atJEk7d+50OsZiZQAAUNO4HHbWr19fFXUAAABUCZfX7Jz1/fffa/Xq1SotLZUkGYbhtqIAAADcxeWwc+zYMXXu3FlNmzbVPffco9zcXEm/LVweO3as2wsEAAC4Ei6HndGjR8vLy0uHDh2Sv7+/o71///5atWqVW4sDAAC4Ui6v2VmzZo1Wr16t+vXrO7U3adJEBw8edFthAAAA7uDyzE5JSYnTjM5ZR48elY+Pj1uKAgAAcBeXw07Hjh311ltvOfZtNpvOnDmjV155RYmJiW4tDgAA4Eq5fBvrlVdeUUJCgrZu3ary8nKNHz9eOTk5+uWXX/TFF19URY0AAACXzeWZnZtuukk7duzQbbfdpq5du6qkpER9+/bVtm3b1KhRo6qoEQAA4LK5PLMjSXa7XZMnT3Z3LQAAAG7n8szOjh07zrtlZ2dr7969Kisru+Rzpaam6tZbb1VgYKDCwsLUp08ffffdd059HnnkEdlsNqft9ttvd+pTVlamkSNHKjQ0VAEBAerVq5eOHDni6tAAAIAFuTyz06pVK8dvYJ19a/LvfxPLy8tL/fv317/+9S/5+vpe9FyZmZkaPny4br31Vp0+fVqTJk1St27dtGvXLgUEBDj63X333Vq4cKFj39vb2+k8ycnJWrlypdLS0lS3bl2NHTtWPXr0UFZWljw8PFwdIgAAsBCXw87y5cv1zDPP6Omnn9Ztt90mwzC0ZcsWTZ8+XS+88IJOnz6tZ599Vn/729/0j3/846LnOvclhAsXLlRYWJiysrLUsWNHR7uPj4/sdvt5z1FYWKgFCxbo7bffVpcuXSRJS5YsUVRUlNauXau77rrL1SECAAALcTnsvPzyy3r11VedQkSLFi1Uv359Pffcc/r6668VEBCgsWPH/mHYOVdhYaEkKSQkxKk9IyNDYWFhuu666xQfH6+XX35ZYWFhkqSsrCydOnVK3bp1c/SPjIxUTEyMNm3adN6wU1ZW5nS7raioyKU6AQDA1cPlNTvZ2dlq2LBhpfaGDRsqOztb0m+3us7+ZtalMgxDY8aM0R133KGYmBhHe1JSkv7973/rs88+0/Tp07VlyxZ16tTJEVby8vLk7e2tOnXqOJ0vPDxceXl5571WamqqgoODHVtUVJRLtQIAgKuHy2GnefPmmjp1qsrLyx1tp06d0tSpU9W8eXNJ0o8//qjw8HCXzjtixAjt2LFD77zzjlN7//791b17d8XExKhnz5769NNPtWfPHn388ccXPZ9hGE5riX5vwoQJKiwsdGyHDx92qVYAAHD1cPk21uuvv65evXqpfv36atGihWw2m3bs2KGKigp99NFHkqR9+/Zp2LBhl3zOkSNH6sMPP9SGDRsq/ebWuSIiItSwYUPt3btX0m+PwZeXl6ugoMBpdic/P19xcXHnPYePjw8/bQEAwDXC5bATFxenAwcOaMmSJdqzZ48Mw9Cf//xnDRgwQIGBgZKkQYMGXdK5DMPQyJEjtXz5cmVkZCg6OvoPP3Ps2DEdPnxYERERkqQ2bdrIy8tL6enp6tevnyQpNzdXO3fu1LRp01wdHgAAsJjLeqlg7dq19eSTT17xxYcPH66lS5fqgw8+UGBgoGONTXBwsPz8/FRcXKyUlBTdd999ioiI0IEDBzRx4kSFhobq3nvvdfQdMmSIxo4dq7p16yokJETjxo1TbGys4+ksAABw7bqssCNJu3bt0qFDh5zW7khSr169Lvkc8+bNkyQlJCQ4tS9cuFCPPPKIPDw8lJ2drbfeekvHjx9XRESEEhMT9e677zpmkSRp5syZ8vT0VL9+/VRaWqrOnTtr0aJFvGMHAAC4Hnb27dune++9V9nZ2bLZbJVeLFhRUXHJ5zr72Qvx8/PT6tWr//A8vr6+mj17tmbPnn3J1wYAANcGl5/GGjVqlKKjo/Xzzz/L399fOTk52rBhg9q2bauMjIwqKBEAAODyuTyz8+WXX+qzzz5TvXr1VKtWLdWqVUt33HGHUlNT9dRTT2nbtm1VUScAAMBlcXlmp6KiQrVr15YkhYaG6qeffpL020sFz/0RTwAAALO5PLMTExOjHTt26IYbblC7du00bdo0eXt7a/78+brhhhuqokYAAIDL5nLY+dvf/qaSkhJJ0ksvvaQePXrozjvvVN26dfXuu++6vUAAAIAr4XLY+f0Pa95www3atWuXfvnlF9WpU+eCP88AAABglst+z87vnfsr5QAAADWFywuUAQAAriaEHQAAYGmEHQAAYGmXFHZat26tgoICSdKLL76okydPVmlRAAAA7nJJYWf37t2Ox80nT56s4uLiKi0KAADAXS7paaxWrVrp0Ucf1R133CHDMPSPf/zD8Rblcz3//PNuLRAAAOBKXFLYWbRokV544QV99NFHstls+vTTT+XpWfmjNpuNsAMAAGqUSwo7zZo1U1pamiSpVq1aWrduncLCwqq0MAAAAHdw+aWCZ86cqYo6AAAAqsRlvUH5hx9+0KxZs7R7927ZbDbdeOONGjVqlBo1auTu+gAAAK6Iy+/ZWb16tW666SZ9/fXXatGihWJiYvTVV1/p5ptvVnp6elXUCAAAcNlcntl59tlnNXr0aE2dOrVS+zPPPKOuXbu6rTgAAIAr5fLMzu7duzVkyJBK7Y899ph27drllqIAAADcxeWwU69ePW3fvr1S+/bt23lCCwAA1Dgu38Z6/PHH9cQTT2jfvn2Ki4uTzWbTxo0b9fe//11jx46tihoBAAAum8th57nnnlNgYKCmT5+uCRMmSJIiIyOVkpKip556yu0FAgAAXAmXw47NZtPo0aM1evRonThxQpIUGBjo9sIAAADc4bLes3MWIQcAANR0Li9QBgAAuJoQdgAAgKURdgAAgKW5FHZOnTqlxMRE7dmzp6rqAQAAcCuXwo6Xl5d27twpm81WVfUAAAC4lcu3sR5++GEtWLCgKmoBAABwO5fDTnl5uebNm6c2bdpo6NChGjNmjNPmitTUVN16660KDAxUWFiY+vTpo++++86pj2EYSklJUWRkpPz8/JSQkKCcnBynPmVlZRo5cqRCQ0MVEBCgXr166ciRI64ODQAAWJDLYWfnzp1q3bq1goKCtGfPHm3bts2xne83sy4mMzNTw4cP1+bNm5Wenq7Tp0+rW7duKikpcfSZNm2aZsyYoTlz5mjLli2y2+3q2rWr44WGkpScnKzly5crLS1NGzduVHFxsXr06KGKigpXhwcAACzG5ZcKrl+/3m0XX7VqldP+woULFRYWpqysLHXs2FGGYWjWrFmaNGmS+vbtK0lavHixwsPDtXTpUg0dOlSFhYVasGCB3n77bXXp0kWStGTJEkVFRWnt2rW666673FYvAAC4+lz2o+fff/+9Vq9erdLSUkm/3W66UoWFhZKkkJAQSdL+/fuVl5enbt26Ofr4+PgoPj5emzZtkiRlZWXp1KlTTn0iIyMVExPj6HOusrIyFRUVOW0AAMCaXA47x44dU+fOndW0aVPdc889ys3NlST95S9/uaJfPTcMQ2PGjNEdd9yhmJgYSVJeXp4kKTw83KlveHi441heXp68vb1Vp06dC/Y5V2pqqoKDgx1bVFTUZdcNAABqNpfDzujRo+Xl5aVDhw7J39/f0d6/f/9Kt6VcMWLECO3YsUPvvPNOpWPnPupuGMYfPv5+sT4TJkxQYWGhYzt8+PBl1w0AAGo2l9fsrFmzRqtXr1b9+vWd2ps0aaKDBw9eVhEjR47Uhx9+qA0bNjid1263S/pt9iYiIsLRnp+f75jtsdvtKi8vV0FBgdPsTn5+vuLi4s57PR8fH/n4+FxWrQAA4Ori8sxOSUmJ04zOWUePHnU5QBiGoREjRmjZsmX67LPPFB0d7XQ8Ojpadrtd6enpjrby8nJlZmY6gkybNm3k5eXl1Cc3N1c7d+68YNgBAADXDpfDTseOHfXWW2859m02m86cOaNXXnlFiYmJLp1r+PDhWrJkiZYuXarAwEDl5eUpLy/PsejZZrMpOTlZU6ZM0fLly7Vz50498sgj8vf314ABAyRJwcHBGjJkiMaOHat169Zp27ZtGjhwoGJjYx1PZwEAgGuXy7exXnnlFSUkJGjr1q0qLy/X+PHjlZOTo19++UVffPGFS+eaN2+eJCkhIcGpfeHChXrkkUckSePHj1dpaamGDRumgoICtWvXTmvWrFFgYKCj/8yZM+Xp6al+/fqptLRUnTt31qJFi+Th4eHq8AAAgMW4HHZuuukm7dixQ/PmzZOHh4dKSkrUt29fDR8+3GldzaW4lMfVbTabUlJSlJKScsE+vr6+mj17tmbPnu3S9QEAgPW5HHak3xYFT5482d21AAAAuN1lhZ2CggItWLBAu3fvls1m04033qhHH33U8TJAAACAmsLlBcqZmZmKjo7Wa6+9poKCAv3yyy967bXXFB0drczMzKqoEQAA4LK5PLMzfPhw9evXz7FmR5IqKio0bNgwDR8+XDt37nR7kQAAAJfL5ZmdH374QWPHjnV60snDw0NjxozRDz/84NbiAAAArpTLYad169bavXt3pfbdu3erVatW7qgJAADAbS7pNtaOHTsc//zUU09p1KhR+v7773X77bdLkjZv3qzXX39dU6dOrZoqAQAALtMlhZ1WrVrJZrM5vRdn/PjxlfoNGDBA/fv3d191AAAAV+iSws7+/furug4AAIAqcUlhp2HDhlVdB2Bp51vndi0JDQ1VgwYNzC4DwDXqsl4q+OOPP+qLL75Qfn6+zpw543TsqaeeckthgBWUFh6TZNPAgQPNLsVUfn7++vbb3QQeAKZwOewsXLhQTz75pLy9vVW3bl3ZbDbHMZvNRtgBfufUyROSDLUa8IzqRTc3uxxTFOUe0FdvTtbRo0cJOwBM4XLYef755/X8889rwoQJqlXL5SfXgWtS7bAGCmnQzOwyAOCa5HJaOXnypB544AGCDgAAuCq4nFiGDBmi9957rypqAQAAcDuXb2OlpqaqR48eWrVqlWJjY+Xl5eV0fMaMGW4rDgAA4Eq5HHamTJmi1atXq1mz39YfnLtAGQAAoCZxOezMmDFDb775ph555JEqKAcAAMC9XF6z4+Pjow4dOlRFLQAAAG7nctgZNWqUZs+eXRW1AAAAuJ3Lt7G+/vprffbZZ/roo4908803V1qgvGzZMrcVBwAAcKVcDjvXXXed+vbtWxW1AAAAuN1l/VwEAADA1YLXIAMAAEtzeWYnOjr6ou/T2bdv3xUVBAAA4E4uh53k5GSn/VOnTmnbtm1atWqVnn76aXfVBQAA4BYuh51Ro0adt/3111/X1q1br7ggAAAAd3Lbmp2kpCS9//777jodAACAW7gt7PznP/9RSEiIu04HAADgFi7fxrrlllucFigbhqG8vDz973//09y5c91aHAAAwJVyOez06dPHab9WrVqqV6+eEhIS1Lx5c3fVBQAA4BYuh50XXnihKuoAAACoEqa+VHDDhg3q2bOnIiMjZbPZtGLFCqfjjzzyiGw2m9N2++23O/UpKyvTyJEjFRoaqoCAAPXq1UtHjhypxlEAAICa7JLDTq1ateTh4XHRzdPTtYmikpIStWzZUnPmzLlgn7vvvlu5ubmO7ZNPPnE6npycrOXLlystLU0bN25UcXGxevTooYqKCpdqAQAA1nTJ6WT58uUXPLZp0ybNnj1bhmG4dPGkpCQlJSVdtI+Pj4/sdvt5jxUWFmrBggV6++231aVLF0nSkiVLFBUVpbVr1+quu+5yqR4AAGA9lxx2evfuXant22+/1YQJE7Ry5Uo99NBD+n//7/+5tThJysjIUFhYmK677jrFx8fr5ZdfVlhYmCQpKytLp06dUrdu3Rz9IyMjFRMTo02bNl0w7JSVlamsrMyxX1RU5Pa6AQBAzXBZa3Z++uknPf7442rRooVOnz6t7du3a/HixWrQoIFbi0tKStK///1vffbZZ5o+fbq2bNmiTp06OYJKXl6evL29VadOHafPhYeHKy8v74LnTU1NVXBwsGOLiopya90AAKDmcCnsFBYW6plnnlHjxo2Vk5OjdevWaeXKlYqJiamS4vr376/u3bsrJiZGPXv21Keffqo9e/bo448/vujnDMO46I+VTpgwQYWFhY7t8OHD7i4dAADUEJd8G2vatGn6+9//Lrvdrnfeeee8t7WqWkREhBo2bKi9e/dKkux2u8rLy1VQUOA0u5Ofn6+4uLgLnsfHx0c+Pj5VXi8AADDfJYedZ599Vn5+fmrcuLEWL16sxYsXn7ffsmXL3FbcuY4dO6bDhw8rIiJCktSmTRt5eXkpPT1d/fr1kyTl5uZq586dmjZtWpXVAQAArh6XHHYefvjhi94auhzFxcX6/vvvHfv79+/X9u3bFRISopCQEKWkpOi+++5TRESEDhw4oIkTJyo0NFT33nuvJCk4OFhDhgzR2LFjVbduXYWEhGjcuHGKjY11PJ0FAACubZccdhYtWuT2i2/dulWJiYmO/TFjxkiSBg8erHnz5ik7O1tvvfWWjh8/roiICCUmJurdd99VYGCg4zMzZ86Up6en+vXrp9LSUnXu3FmLFi2Sh4eH2+sFAABXH5d/LsKdEhISLvpuntWrV//hOXx9fTV79mzNnj3bnaUBAACLMPXnIgAAAKoaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFiaqWFnw4YN6tmzpyIjI2Wz2bRixQqn44ZhKCUlRZGRkfLz81NCQoJycnKc+pSVlWnkyJEKDQ1VQECAevXqpSNHjlTjKAAAQE1matgpKSlRy5YtNWfOnPMenzZtmmbMmKE5c+Zoy5Ytstvt6tq1q06cOOHok5ycrOXLlystLU0bN25UcXGxevTooYqKiuoaBgAAqME8zbx4UlKSkpKSznvMMAzNmjVLkyZNUt++fSVJixcvVnh4uJYuXaqhQ4eqsLBQCxYs0Ntvv60uXbpIkpYsWaKoqCitXbtWd911V7WNBQAA1Ew1ds3O/v37lZeXp27dujnafHx8FB8fr02bNkmSsrKydOrUKac+kZGRiomJcfQ5n7KyMhUVFTltAADAmmps2MnLy5MkhYeHO7WHh4c7juXl5cnb21t16tS5YJ/zSU1NVXBwsGOLiopyc/UAAKCmqLFh5yybzea0bxhGpbZz/VGfCRMmqLCw0LEdPnzYLbUCAICap8aGHbvdLkmVZmjy8/Mdsz12u13l5eUqKCi4YJ/z8fHxUVBQkNMGAACsqcaGnejoaNntdqWnpzvaysvLlZmZqbi4OElSmzZt5OXl5dQnNzdXO3fudPQBAADXNlOfxiouLtb333/v2N+/f7+2b9+ukJAQNWjQQMnJyZoyZYqaNGmiJk2aaMqUKfL399eAAQMkScHBwRoyZIjGjh2runXrKiQkROPGjVNsbKzj6SwAAHBtMzXsbN26VYmJiY79MWPGSJIGDx6sRYsWafz48SotLdWwYcNUUFCgdu3aac2aNQoMDHR8ZubMmfL09FS/fv1UWlqqzp07a9GiRfLw8Kj28QAAgJrH1LCTkJAgwzAueNxmsyklJUUpKSkX7OPr66vZs2dr9uzZVVAhAAC42tXYNTsAAADuQNgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACW5ml2AQCuDbt37za7BNOEhoaqQYMGZpcBXLMIOwCqVGnhMUk2DRw40OxSTOPn569vv91N4AFMQtgBUKVOnTwhyVCrAc+oXnRzs8updkW5B/TVm5N19OhRwg5gEsIOgGpRO6yBQho0M7sMANcgFigDAABLq9FhJyUlRTabzWmz2+2O44ZhKCUlRZGRkfLz81NCQoJycnJMrBgAANQ0NTrsSNLNN9+s3Nxcx5adne04Nm3aNM2YMUNz5szRli1bZLfb1bVrV504ccLEigEAQE1S48OOp6en7Ha7Y6tXr56k32Z1Zs2apUmTJqlv376KiYnR4sWLdfLkSS1dutTkqgEAQE1R48PO3r17FRkZqejoaD3wwAPat2+fJGn//v3Ky8tTt27dHH19fHwUHx+vTZs2XfScZWVlKioqctoAAIA11eiw065dO7311ltavXq13njjDeXl5SkuLk7Hjh1TXl6eJCk8PNzpM+Hh4Y5jF5Kamqrg4GDHFhUVVWVjAAAA5qrRYScpKUn33XefYmNj1aVLF3388ceSpMWLFzv62Gw2p88YhlGp7VwTJkxQYWGhYzt8+LD7iwcAADVCjQ475woICFBsbKz27t3reCrr3Fmc/Pz8SrM95/Lx8VFQUJDTBgAArOmqCjtlZWXavXu3IiIiFB0dLbvdrvT0dMfx8vJyZWZmKi4uzsQqAQBATVKj36A8btw49ezZUw0aNFB+fr5eeuklFRUVafDgwbLZbEpOTtaUKVPUpEkTNWnSRFOmTJG/v78GDBhgdukAAKCGqNFh58iRI3rwwQd19OhR1atXT7fffrs2b96shg0bSpLGjx+v0tJSDRs2TAUFBWrXrp3WrFmjwMBAkysHAAA1RY0OO2lpaRc9brPZlJKSopSUlOopCAAAXHWuqjU7AAAAriLsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAASyPsAAAAS6vRv3oOAFaxe/dus0swVWhoqBo0aGB2GbhGEXYAoAqVFh6TZNPAgQPNLsVUfn7++vbb3QQemIKwAwBV6NTJE5IMtRrwjOpFNze7HFMU5R7QV29O1tGjRwk7MAVhBwCqQe2wBgpp0MzsMoBrEguUAQCApRF2AACApRF2AACApRF2AACApRF2AACApRF2AACApRF2AACApRF2AACApRF2AACApRF2AACApRF2AACApRF2AACApfFDoACAarF7926zSzBNaGgov/huIsIOAKBKlRYek2TTwIEDzS7FNH5+/vr2290EHpNYJuzMnTtXr7zyinJzc3XzzTdr1qxZuvPOO80uCwCueadOnpBkqNWAZ1QvurnZ5VS7otwD+urNyTp69ChhxySWCDvvvvuukpOTNXfuXHXo0EH/+te/lJSUpF27dvEHCwBqiNphDRTSoJnZZeAaZImwM2PGDA0ZMkR/+ctfJEmzZs3S6tWrNW/ePKWmpppcHQAArFkyc/Lhqg875eXlysrK0rPPPuvU3q1bN23atMmkqgAA+A1rlsxfs3TVh52jR4+qoqJC4eHhTu3h4eHKy8s772fKyspUVlbm2C8sLJQkFRUVubW24uJiSdIvB7/T6bJSt577alGUe1CSVPjjXnl52kyupvpd6+OX+A6u9fFLfAfHftgpydANCfcrOLy+2eVUu5O//Kzv0pfqwIEDuu6669x67rN/bxuGcfGOxlXuxx9/NCQZmzZtcmp/6aWXjGbNmp33My+88IIhiY2NjY2Njc0C2+HDhy+aFa76mZ3Q0FB5eHhUmsXJz8+vNNtz1oQJEzRmzBjH/pkzZ/TLL7+obt26stms9X8dRUVFioqK0uHDhxUUFGR2OdWO8V/b45f4Dq718Ut8B1Yev2EYOnHihCIjIy/a76oPO97e3mrTpo3S09N17733OtrT09PVu3fv837Gx8dHPj4+Tm3unlqraYKCgiz3h9wVjP/aHr/Ed3Ctj1/iO7Dq+IODg/+wz1UfdiRpzJgxGjRokNq2bav27dtr/vz5OnTokJ588kmzSwMAACazRNjp37+/jh07phdffFG5ubmKiYnRJ598ooYNG5pdGgAAMJklwo4kDRs2TMOGDTO7jBrHx8dHL7zwQqXbdtcKxn9tj1/iO7jWxy/xHVzr45ckm2H80fNaAAAAV69aZhcAAABQlQg7AADA0gg7AADA0gg7AADA0gg7FjZ37lxFR0fL19dXbdq00eeff252SdVmw4YN6tmzpyIjI2Wz2bRixQqzS6pWqampuvXWWxUYGKiwsDD16dNH3333ndllVat58+apRYsWjheptW/fXp9++qnZZZkmNTVVNptNycnJZpdSLVJSUmSz2Zw2u91udlnV7scff9TAgQNVt25d+fv7q1WrVsrKyjK7rGpH2LGod999V8nJyZo0aZK2bdumO++8U0lJSTp06JDZpVWLkpIStWzZUnPmzDG7FFNkZmZq+PDh2rx5s9LT03X69Gl169ZNJSUlZpdWberXr6+pU6dq69at2rp1qzp16qTevXsrJyfH7NKq3ZYtWzR//ny1aNHC7FKq1c0336zc3FzHlp2dbXZJ1aqgoEAdOnSQl5eXPv30U+3atUvTp0+3/C8GnA+PnltUu3bt1Lp1a82bN8/RduONN6pPnz5KTU01sbLqZ7PZtHz5cvXp08fsUkzzv//9T2FhYcrMzFTHjh3NLsc0ISEheuWVVzRkyBCzS6k2xcXFat26tebOnauXXnpJrVq10qxZs8wuq8qlpKRoxYoV2r59u9mlmObZZ5/VF198cU3N6l8IMzsWVF5erqysLHXr1s2pvVu3btq0aZNJVcFMhYWFkn77y/5aVFFRobS0NJWUlKh9+/Zml1Othg8fru7du6tLly5ml1Lt9u7dq8jISEVHR+uBBx7Qvn37zC6pWn344Ydq27at7r//foWFhemWW27RG2+8YXZZpiDsWNDRo0dVUVFR6Vffw8PDK/06PKzPMAyNGTNGd9xxh2JiYswup1plZ2erdu3a8vHx0ZNPPqnly5frpptuMrusapOWlqZvvvnmmpvNlX6b3X7rrbe0evVqvfHGG8rLy1NcXJyOHTtmdmnVZt++fZo3b56aNGmi1atX68knn9RTTz2lt956y+zSqp1lfi4CldlsNqd9wzAqtcH6RowYoR07dmjjxo1ml1LtmjVrpu3bt+v48eN6//33NXjwYGVmZl4Tgefw4cMaNWqU1qxZI19fX7PLqXZJSUmOf46NjVX79u3VqFEjLV68WGPGjDGxsupz5swZtW3bVlOmTJEk3XLLLcrJydG8efP08MMPm1xd9WJmx4JCQ0Pl4eFRaRYnPz+/0mwPrG3kyJH68MMPtX79etWvX9/scqqdt7e3GjdurLZt2yo1NVUtW7bUq6++anZZ1SIrK0v5+flq06aNPD095enpqczMTL322mvy9PRURUWF2SVWq4CAAMXGxmrv3r1ml1JtIiIiKgX7G2+88Zp5UOX3CDsW5O3trTZt2ig9Pd2pPT09XXFxcSZVhepkGIZGjBihZcuW6bPPPlN0dLTZJdUIhmGorKzM7DKqRefOnZWdna3t27c7trZt2+qhhx7S9u3b5eHhYXaJ1aqsrEy7d+9WRESE2aVUmw4dOlR65cSePXvUsGFDkyoyD7exLGrMmDEaNGiQ2rZtq/bt22v+/Pk6dOiQnnzySbNLqxbFxcX6/vvvHfv79+/X9u3bFRISogYNGphYWfUYPny4li5dqg8++ECBgYGOWb7g4GD5+fmZXF31mDhxopKSkhQVFaUTJ04oLS1NGRkZWrVqldmlVYvAwMBKa7QCAgJUt27da2Lt1rhx49SzZ081aNBA+fn5eumll1RUVKTBgwebXVq1GT16tOLi4jRlyhT169dPX3/9tebPn6/58+ebXVr1M2BZr7/+utGwYUPD29vbaN26tZGZmWl2SdVm/fr1hqRK2+DBg80urVqcb+ySjIULF5pdWrV57LHHHH/+69WrZ3Tu3NlYs2aN2WWZKj4+3hg1apTZZVSL/v37GxEREYaXl5cRGRlp9O3b18jJyTG7rGq3cuVKIyYmxvDx8TGaN29uzJ8/3+ySTMF7dgAAgKWxZgcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQfANSshIUHJyckX7bNo0SJdd9111VIPgKpB2AFgun/+858KDAzU6dOnHW3FxcXy8vLSnXfe6dT3888/l81m0549e9xex/XXX69Zs2a5/bwAzEXYAWC6xMREFRcXa+vWrY62zz//XHa7XVu2bNHJkycd7RkZGYqMjFTTpk3NKBXAVYiwA8B0zZo1U2RkpDIyMhxtGRkZ6t27txo1aqRNmzY5tScmJqq8vFzjx4/Xn/70JwUEBKhdu3ZOnz927JgefPBB1a9fX/7+/oqNjdU777xzwRoSEhJ08OBBjR49WjabTTabzen46tWrdeONN6p27dq6++67lZub67bxA6hahB0ANUJCQoLWr1/v2F+/fr0SEhIUHx/vaC8vL9eXX36pxMREPfroo/riiy+UlpamHTt26P7779fdd9+tvXv3SpJ+/fVXtWnTRh999JF27typJ554QoMGDdJXX3113usvW7ZM9evX14svvqjc3FynMHPy5En94x//0Ntvv60NGzbo0KFDGjduXBV+GwDcydPsAgBA+i3sjB49WqdPn1Zpaam2bdumjh07qqKiQq+99pokafPmzSotLVVCQoIef/xxHTlyRJGRkZKkcePGadWqVVq4cKGmTJmiP/3pT06BZOTIkVq1apXee+89tWvXrtL1Q0JC5OHhocDAQNntdqdjp06d0j//+U81atRIkjRixAi9+OKLVfVVAHAzwg6AGiExMVElJSXasmWLCgoK1LRpU4WFhSk+Pl6DBg1SSUmJMjIy1KBBA33zzTcyDKPSup2ysjLVrVtXklRRUaGpU6fq3Xff1Y8//qiysjKVlZUpICDA5dr8/f0dQUeSIiIilJ+ff2UDBlBtCDsAaoTGjRurfv36Wr9+vQoKChQfHy9Jstvtio6O1hdffKH169erU6dOOnPmjDw8PJSVlSUPDw+n89SuXVuSNH36dM2cOVOzZs1SbGysAgIClJycrPLycpdr8/Lyctq32WwyDOMyRwqguhF2ANQYiYmJysjIUEFBgZ5++mlHe3x8vFavXq3Nmzfr0Ucf1S233KKKigrl5+dXejT9rM8//1y9e/fWwIEDJUlnzpzR3r17deONN17w+t7e3qqoqHDvoACYjgXKAGqMxMREbdy4Udu3b3fM7Ei/hZ033nhDv/76qxITE9W0aVM99NBDevjhh7Vs2TLt379fW7Zs0d///nd98sknkn6bKUpPT9emTZu0e/duDR06VHl5eRe9/vXXX68NGzboxx9/1NGjR6t0rACqD2EHQI2RmJio0tJSNW7cWOHh4Y72+Ph4nThxQo0aNVJUVJQkaeHChXr44Yc1duxYNWvWTL169dJXX33lOP7cc8+pdevWuuuuu5SQkCC73a4+ffpc9PovvviiDhw4oEaNGqlevXpVNk4A1ctmcOMZAABYGDM7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0gg7AADA0v4/bFhtuGxAkD8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "all_wealth = []\n", "# This runs the model 100 times, each model executing 10 steps.\n", @@ -518,7 +575,7 @@ " model.step()\n", "\n", " # Store the results\n", - " for agent in model.schedule.agents:\n", + " for agent in model.agents:\n", " all_wealth.append(agent.wealth)\n", "\n", "# Use seaborn\n", @@ -559,7 +616,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -570,12 +627,10 @@ " super().__init__()\n", " self.num_agents = N\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", - " self.schedule = mesa.time.RandomActivation(self)\n", "\n", " # Create agents\n", " for _ in range(self.num_agents):\n", " a = MoneyAgent(self)\n", - " self.schedule.add(a)\n", "\n", " # Add the agent to a random grid cell\n", " x = self.random.randrange(self.grid.width)\n", @@ -646,7 +701,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -684,18 +739,17 @@ " super().__init__()\n", " self.num_agents = N\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", - " self.schedule = mesa.time.RandomActivation(self)\n", + " \n", " # Create agents\n", " for _ in range(self.num_agents):\n", " a = MoneyAgent(self)\n", - " self.schedule.add(a)\n", " # Add the agent to a random grid cell\n", " x = self.random.randrange(self.grid.width)\n", " y = self.random.randrange(self.grid.height)\n", " self.grid.place_agent(a, (x, y))\n", "\n", " def step(self):\n", - " self.schedule.step()" + " self.agents.shuffle_do(\"step\")" ] }, { @@ -707,7 +761,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -725,9 +779,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "agent_counts = np.zeros((model.grid.width, model.grid.height))\n", "for cell_content, (x, y) in model.grid.coord_iter():\n", @@ -756,12 +821,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def compute_gini(model):\n", - " agent_wealths = [agent.wealth for agent in model.schedule.agents]\n", + " agent_wealths = [agent.wealth for agent in model.agents]\n", " x = sorted(agent_wealths)\n", " N = model.num_agents\n", " B = sum(xi * (N - i) for i, xi in enumerate(x)) / (N * sum(x))\n", @@ -807,12 +872,10 @@ " super().__init__()\n", " self.num_agents = N\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", - " self.schedule = mesa.time.RandomActivation(self)\n", "\n", " # Create agents\n", " for _ in range(self.num_agents):\n", " a = MoneyAgent(self)\n", - " self.schedule.add(a)\n", " # Add the agent to a random grid cell\n", " x = self.random.randrange(self.grid.width)\n", " y = self.random.randrange(self.grid.height)\n", @@ -824,7 +887,7 @@ "\n", " def step(self):\n", " self.datacollector.collect(self)\n", - " self.schedule.step()" + " self.agents.shuffle_do(\"step\")" ] }, { @@ -840,7 +903,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -858,9 +921,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "gini = model.datacollector.get_model_vars_dataframe()\n", "# Plot the Gini coefficient over time\n", @@ -877,9 +951,80 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Wealth
StepAgentID
111
21
31
41
51
\n", + "
" + ], + "text/plain": [ + " Wealth\n", + "Step AgentID \n", + "1 1 1\n", + " 2 1\n", + " 3 1\n", + " 4 1\n", + " 5 1" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "agent_wealth = model.datacollector.get_agent_vars_dataframe()\n", "agent_wealth.head()" @@ -894,9 +1039,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "last_step = agent_wealth.index.get_level_values(\"Step\").max()\n", "end_wealth = agent_wealth.xs(last_step, level=\"Step\")[\"Wealth\"]\n", @@ -918,9 +1074,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Get the wealth of agent 14 over time\n", "one_agent_wealth = agent_wealth.xs(14, level=\"AgentID\")\n", @@ -939,9 +1106,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "agent_list = [3, 14, 25]\n", "\n", @@ -963,9 +1141,30 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 1.0, 'Average wealth over time')]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Transform the data to a long format\n", "agent_wealth_long = agent_wealth.T.unstack().reset_index()\n", @@ -1029,12 +1228,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "def compute_gini(model):\n", - " agent_wealths = [agent.wealth for agent in model.schedule.agents]\n", + " agent_wealths = [agent.wealth for agent in model.agents]\n", " x = sorted(agent_wealths)\n", " N = model.num_agents\n", " B = sum(xi * (N - i) for i, xi in enumerate(x)) / (N * sum(x))\n", @@ -1048,13 +1247,11 @@ " super().__init__()\n", " self.num_agents = N\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", - " self.schedule = mesa.time.RandomActivation(self)\n", " self.running = True\n", "\n", " # Create agents\n", " for _ in range(self.num_agents):\n", " a = MoneyAgent(self)\n", - " self.schedule.add(a)\n", " # Add the agent to a random grid cell\n", " x = self.random.randrange(self.grid.width)\n", " y = self.random.randrange(self.grid.height)\n", @@ -1067,7 +1264,7 @@ "\n", " def step(self):\n", " self.datacollector.collect(self)\n", - " self.schedule.step()\n", + " self.agents.shuffle_do(\"step\")\n", "\n", "\n", "class MoneyAgent(mesa.Agent):\n", @@ -1153,9 +1350,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "71f6949783314c9da5a151f2a9510531", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/133 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Filter the results to only contain the data of one agent (the Gini coefficient will be the same for the entire population at any time) at the 100th step of each episode\n", - "results_filtered = results_df[(results_df.AgentID == 0) & (results_df.Step == 100)]\n", + "results_filtered = results_df[(results_df.AgentID == 1) & (results_df.Step == 100)]\n", "results_filtered[[\"iteration\", \"N\", \"Gini\"]].reset_index(\n", " drop=True\n", ").head() # Create a scatter plot\n", @@ -1216,7 +1449,10 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "source": [ "We can create different kinds of plot from this filtered DataFrame. For example, a point plot with error bars." @@ -1224,11 +1460,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Create a point plot with error bars\n", "g = sns.pointplot(data=results_filtered, x=\"N\", y=\"Gini\", linestyle='none')\n", @@ -1252,9 +1502,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Step AgentID Wealth\n", + " 0 NaN NaN\n", + " 1 1.0 1.0\n", + " 1 2.0 1.0\n", + " 1 3.0 1.0\n", + " 1 4.0 1.0\n", + " ... ... ...\n", + " 100 6.0 1.0\n", + " 100 7.0 2.0\n", + " 100 8.0 2.0\n", + " 100 9.0 1.0\n", + " 100 10.0 1.0\n" + ] + } + ], "source": [ "# First, we filter the results\n", "one_episode_wealth = results_df[(results_df.N == 10) & (results_df.iteration == 2)]\n", @@ -1278,12 +1547,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Step Gini\n", + " 1 0.00\n", + " 2 0.00\n", + " 3 0.18\n", + " 4 0.18\n", + " 5 0.42\n", + " ... ...\n", + " 96 0.66\n", + " 97 0.66\n", + " 98 0.66\n", + " 99 0.66\n", + " 100 0.66\n" + ] + } + ], "source": [ "results_one_episode = results_df[\n", - " (results_df.N == 10) & (results_df.iteration == 1) & (results_df.AgentID == 0)\n", + " (results_df.N == 10) & (results_df.iteration == 1) & (results_df.AgentID == 1)\n", "]\n", "print(results_one_episode.to_string(index=False, columns=[\"Step\", \"Gini\"], max_rows=10))" ] @@ -1291,7 +1579,10 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "source": [ "### Analyzing model reporters: Comparing 5 scenarios\n", @@ -1300,11 +1591,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "60f4353fc39647378e6fd084bef80c1c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/500 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RunIditerationStepwidthheightNGiniAgentIDWealthSteps_not_given
1001101050.01.01.00.0
6002101050.01.01.01.0
11003101050.01.01.02.0
\n", + "" + ], + "text/plain": [ + " RunId iteration Step width height N Gini AgentID Wealth \\\n", + "1 0 0 1 10 10 5 0.0 1.0 1.0 \n", + "6 0 0 2 10 10 5 0.0 1.0 1.0 \n", + "11 0 0 3 10 10 5 0.0 1.0 1.0 \n", + "\n", + " Steps_not_given \n", + "1 0.0 \n", + "6 1.0 \n", + "11 2.0 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Again filter the results to only contain the data of one agent (the Gini coefficient will be the same for the entire population at any time)\n", - "results_5s_df_filtered = results_5s_df[(results_5s_df.AgentID == 0)]\n", + "results_5s_df_filtered = results_5s_df[(results_5s_df.AgentID == 1)]\n", "results_5s_df_filtered.head(3)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Create a lineplot with error bars\n", "g = sns.lineplot(\n", @@ -1359,7 +1779,10 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "source": [ "In this case it looks like the Gini coefficient increases slower for smaller populations. This can be because of different things, either because the Gini coefficient is a measure of inequality and the smaller the population, the more likely it is that the agents are all in the same wealth class, or because there are less interactions between agents in smaller populations, which means that the wealth of an agent is less likely to change." @@ -1368,7 +1791,10 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "source": [ "### Analyzing agent reporters\n", @@ -1379,11 +1805,83 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
iterationNStepWealthSteps_not_given
0050NaNNaN
10511.00.0
20521.01.0
\n", + "
" + ], + "text/plain": [ + " iteration N Step Wealth Steps_not_given\n", + "0 0 5 0 NaN NaN\n", + "1 0 5 1 1.0 0.0\n", + "2 0 5 2 1.0 1.0" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Calculate the mean of the wealth and the number of consecutive rounds for all agents in each episode\n", "agg_results_df = (\n", @@ -1396,11 +1894,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Create a line plot with error bars\n", "g = sns.lineplot(\n", @@ -1416,7 +1928,10 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "source": [ "It can be clearly seen that the lower the number of agents, the higher the number of consecutive rounds without a transaction. This is because the agents have fewer interactions with each other and therefore the wealth of an agent is less likely to change." @@ -1425,7 +1940,10 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, "source": [ "#### General steps for analyzing results\n", @@ -1477,7 +1995,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.5" }, "widgets": { "state": {}, diff --git a/docs/tutorials/visualization_tutorial.ipynb b/docs/tutorials/visualization_tutorial.ipynb index b536752fba6..16b627c4050 100644 --- a/docs/tutorials/visualization_tutorial.ipynb +++ b/docs/tutorials/visualization_tutorial.ipynb @@ -42,13 +42,22 @@ "outputs": [], "source": [ "# Install and import the latest Mesa pre-release version\n", + "%pip install solara # to prevent installing Solara's pre-release which is not compatabilt\n", "%pip install --quiet --upgrade --pre mesa\n", "import mesa\n", "print(f\"Mesa version: {mesa.__version__}\")\n", "\n", "# You can either define the BoltzmannWealthModel (aka MoneyModel) or install mesa-models:\n", - "%pip install --quiet -U git+https://github.com/projectmesa/mesa-examples#egg=mesa-models\n", - "\n", + "%pip install --quiet -U git+https://github.com/projectmesa/mesa-examples#egg=mesa-models" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#import BoltzmannWealthModel\n", "from mesa_models.boltzmann_wealth_model.model import BoltzmannWealthModel" ] }, @@ -61,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "tags": [] }, @@ -83,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -117,10 +126,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, + "execution_count": 7, + "metadata": {}, "outputs": [], "source": [ "from mesa.visualization import SolaraViz, make_plot_measure, make_space_matplotlib\n", @@ -129,8 +136,17 @@ "model1 = BoltzmannWealthModel(50, 10, 10)\n", "\n", "SpaceGraph = make_space_matplotlib(agent_portrayal)\n", - "GiniPlot = make_plot_measure(\"Gini\")\n", - "\n", + "GiniPlot = make_plot_measure(\"Gini\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ "page = SolaraViz(\n", " model1,\n", " components=[SpaceGraph, GiniPlot],\n", @@ -155,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -199,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -228,9 +244,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "57517eda09044c869bb633d0b970bc02", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "Cannot show widget. You probably want to rerun the code cell above (Click in the code cell, and press Shift+Enter +)." + ], + "text/plain": [ + "Cannot show ipywidgets in text" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "Histogram(model1)" ] @@ -244,9 +278,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6eb4c9960af74181b0ffd1bed8998e72", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "Cannot show widget. You probably want to rerun the code cell above (Click in the code cell, and press Shift+Enter +)." + ], + "text/plain": [ + "Cannot show ipywidgets in text" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "page = SolaraViz(\n", " model1,\n", @@ -270,7 +322,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -284,7 +336,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.6" + "version": "3.12.5" }, "nbsphinx": { "execute": "never" From 06ada8dea5ae444d5a5a769392dc30009d27fad5 Mon Sep 17 00:00:00 2001 From: Tom Pike Date: Fri, 18 Oct 2024 05:54:38 -0400 Subject: [PATCH 2/6] Update intro_tutorial.ipynb - Updates descriptions to be consistent with 3.0 - Adds user challenges - Corrects headers --- docs/tutorials/intro_tutorial.ipynb | 334 +++++++++++++++++----------- 1 file changed, 209 insertions(+), 125 deletions(-) diff --git a/docs/tutorials/intro_tutorial.ipynb b/docs/tutorials/intro_tutorial.ipynb index f6071e06de1..35ab9923c1e 100644 --- a/docs/tutorials/intro_tutorial.ipynb +++ b/docs/tutorials/intro_tutorial.ipynb @@ -141,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 1, "metadata": { "collapsed": false, "jupyter": { @@ -182,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -209,22 +209,22 @@ "\n", "**Model-specific information:** When a model is created the number of agents within the model is specified. The model then creates the agents and places them in an set of agents. \n", "\n", - "**Code implementation:** This is done by creating a new class (or object) that extends `mesa.Model` and calls `super().__init__()`, creating a subclass of the `Model` class from mesa. The new class is named `MoneyModel`. The technical details about the model object can be found in [model module](https://github.com/projectmesa/mesa/blob/main/mesa/model.py) and the AgentSet in the [agent module](https://github.com/projectmesa/mesa/blob/d7a3834c99a3be809abe2edc8b83610f3d4438ba/mesa/agent.py#L86).\n", + "**Code implementation:** This is done by creating a new class (or object) that extends `mesa.Model` and calls `super().__init__()`, creating a subclass of the `Model` class from mesa. The new class is named `MoneyModel`. The technical details about the model object can be found in [model module](https://github.com/projectmesa/mesa/blob/main/mesa/model.py) and the AgentSet in the [agent module](https://github.com/projectmesa/mesa/blob/d7a3834c99a3be809abe2edc8b83610f3d4438ba/mesa/agent.py#L86). A critical point is that you can use the `seed` kwarg (keyword argument) to set a seed which controls the random number generator of the model class allowing for the reproducibility of results. \n", "\n", "The `MoneyModel` class is created with the following code:" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N):\n", - " super().__init__()\n", + " def __init__(self, N, seed=None):\n", + " super().__init__(seed=seed)\n", " self.num_agents = N\n", " # Create agents\n", " for _ in range(self.num_agents):\n", @@ -249,7 +249,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -272,8 +272,8 @@ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N):\n", - " super().__init__()\n", + " def __init__(self, N, seed=None):\n", + " super().__init__(seed=seed)\n", " self.num_agents = N\n", " \n", " # Create agents\n", @@ -310,22 +310,22 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Hi, I am an agent, you can call me 2.\n", - "Hi, I am an agent, you can call me 5.\n", - "Hi, I am an agent, you can call me 8.\n", - "Hi, I am an agent, you can call me 9.\n", - "Hi, I am an agent, you can call me 1.\n", "Hi, I am an agent, you can call me 6.\n", - "Hi, I am an agent, you can call me 10.\n", + "Hi, I am an agent, you can call me 5.\n", "Hi, I am an agent, you can call me 4.\n", + "Hi, I am an agent, you can call me 1.\n", + "Hi, I am an agent, you can call me 9.\n", "Hi, I am an agent, you can call me 3.\n", + "Hi, I am an agent, you can call me 2.\n", + "Hi, I am an agent, you can call me 10.\n", + "Hi, I am an agent, you can call me 8.\n", "Hi, I am an agent, you can call me 7.\n" ] } @@ -337,7 +337,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 6, "metadata": { "collapsed": false, "jupyter": { @@ -349,16 +349,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Hi, I am an agent, you can call me 2.\n", + "Hi, I am an agent, you can call me 6.\n", + "Hi, I am an agent, you can call me 9.\n", "Hi, I am an agent, you can call me 4.\n", "Hi, I am an agent, you can call me 8.\n", + "Hi, I am an agent, you can call me 2.\n", "Hi, I am an agent, you can call me 3.\n", - "Hi, I am an agent, you can call me 9.\n", "Hi, I am an agent, you can call me 5.\n", "Hi, I am an agent, you can call me 7.\n", - "Hi, I am an agent, you can call me 1.\n", - "Hi, I am an agent, you can call me 6.\n", - "Hi, I am an agent, you can call me 10.\n" + "Hi, I am an agent, you can call me 10.\n", + "Hi, I am an agent, you can call me 1.\n" ] } ], @@ -367,17 +367,35 @@ "starter_model.step()" ] }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Challenge: Change the seed from None to a number like 42 and see the impact" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Challenge: Change `shuffle_do` to just `do` and see the impact" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Exercise\n", + "### Exercise\n", "Modifying the code below to have every agent print out its `wealth` when it is activated." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "collapsed": false, "jupyter": { @@ -411,7 +429,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "collapsed": false, "jupyter": { @@ -423,6 +441,15 @@ "# Fixme: Create the model object, and run it" ] }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Challenge: Change the agent step function to some else like \"talk\" function and call it from `shuffle_do`" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -435,27 +462,17 @@ "\n", "**Model-specific information:** In this case, the agent will check its wealth, and if it has money, give one unit of it away to another random agent.\n", "\n", - "**Code implementation:** The agent's step method is called by the scheduler during each step of the model. To allow the agent to choose another agent at random, we use the `model.random` random-number generator. This works just like Python's `random` module, but with a fixed seed set when the model is instantiated, that can be used to replicate a specific model run later." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To pick an agent at random, we need a list of all agents. Notice that there isn't such a list explicitly in the model. The scheduler, however, does have an internal list of all the agents it is scheduled to activate.\n", + "**Code implementation:** The agent's step method is called by `mesa.Agent.shuffle_do(\"step\")`during each step of the model. To allow the agent to choose another agent at random, we use the `model.random` random-number generator. This works just like Python's `random` module, but if a fixed seed set is set when the model is instantiated (see earlier challenge), this allows users to replicate a specific model run later. Once we identify this other agent object we increase their wealth by 1 and decrease this agents wealth by one.\n", "\n", - "With that in mind, we rewrite the agent `step` method as shown below:" + "This updates the step function as shown below" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "import copy\n", - "\n", - "\n", "class MoneyAgent(mesa.Agent):\n", " \"\"\"An agent with fixed initial wealth.\"\"\"\n", "\n", @@ -494,12 +511,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "model = MoneyModel(10)\n", - "for _ in range(10):\n", + "model = MoneyModel(10) # Tels the model to create 10 agents\n", + "for _ in range(10): #Runs the model for 10 steps; an underscore is common convetion for a variable that is not used\n", " model.step()" ] }, @@ -512,12 +529,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -551,12 +568,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -596,15 +613,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Adding space\n", + "## Adding space\n", + "\n", + "**Background:** Many ABMs have a spatial element, with agents moving around and interacting with nearby neighbors. Mesa has several types of [spaces](https://mesa.readthedocs.io/latest/apis/space.html) from different types of grids to networks to an in development [cell_space](https://mesa.readthedocs.io/latest/apis/experimental.html#module-experimental.cell_space.__init__). Mesa grids are divided into cells, and agents can only be on a particular cell, like pieces on a chess board. Continuous space, in contrast, allows agents to have any arbitrary position. (Think of grids vs continuous space like the difference between integers and decimals.)\n", "\n", - "Many ABMs have a spatial element, with agents moving around and interacting with nearby neighbors. Mesa currently supports two overall kinds of spaces: grid, and continuous. Grids are divided into cells, and agents can only be on a particular cell, like pieces on a chess board. Continuous space, in contrast, allows agents to have any arbitrary position. Both grids and continuous spaces are frequently [toroidal](https://en.wikipedia.org/wiki/Toroidal_graph), meaning that the edges wrap around, with cells on the right edge connected to those on the left edge, and the top to the bottom. This prevents some cells having fewer neighbors than others, or agents being able to go off the edge of the environment.\n", + "Both grids and continuous spaces are frequently [toroidal](https://en.wikipedia.org/wiki/Toroidal_graph), meaning that the edges wrap around, with cells on the right edge connected to those on the left edge, and the top to the bottom. This prevents some cells having fewer neighbors than others, or agents being able to go off the edge of the environment. You can envision a torous by thinking of donut.\n", "\n", - "Let's add a simple spatial element to our model by putting our agents on a grid and make them walk around at random. Instead of giving their unit of money to any random agent, they'll give it to an agent on the same cell.\n", + "Mesa has two main types of grids: `SingleGrid` and `MultiGrid`. `SingleGrid` enforces at most one agent per cell; `MultiGrid` allows multiple agents to be in the same cell. We are going to use `MultiGrid` and then only exchange money with agents in the same cell.\n", "\n", - "Mesa has two main types of grids: `SingleGrid` and `MultiGrid`*. `SingleGrid` enforces at most one agent per cell; `MultiGrid` allows multiple agents to be in the same cell. Since we want agents to be able to share a cell, we use `MultiGrid`.\n", + "**Model-specific information:** Let's add a simple spatial element to our model by putting our agents on a grid and make them walk around at random. Instead of giving their unit of money to any random agent, they'll give it to an agent on the same cell. For the Money model multiple agents can be in the same spaces and since they are on a torus the agents on the left side can exchange money with agent on the right. Agents on the top can exchange with agents on the bottom.\n", "\n", - "*However there are more types of space to include `HexGrid`, `NetworkGrid`, and the previously mentioned `ContinuousSpace`. Similar to `mesa.time` context is retained with `mesa.space.[enter class]`. You can inspect the different classes at [mesa.space](https://github.com/projectmesa/mesa/blob/main/mesa/space.py)." + "**Code Implementation:** We get a random integer within the width and height of the grid space and the use Mesa's multigrid `place_agent` function to place the agent in the specificed grid location." ] }, { @@ -616,15 +635,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, width, height):\n", - " super().__init__()\n", + " def __init__(self, N, width, height, seed=None):\n", + " super().__init__(seed=seed)\n", " self.num_agents = N\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", "\n", @@ -642,6 +661,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "#### Moving in Mesa\n", + "\n", "Under the hood, each agent's position is stored in two ways: the agent is contained in the grid in the cell it is currently in, and the agent has a `pos` variable with an (x, y) coordinate tuple. The `place_agent` method adds the coordinate to the agent automatically.\n", "\n", "Now we need to add to the agents' behaviors, letting them move around and only give money to other agents in the same cell.\n", @@ -701,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -735,8 +756,8 @@ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, width, height):\n", - " super().__init__()\n", + " def __init__(self, N, width, height,seed=None):\n", + " super().__init__(seed=seed)\n", " self.num_agents = N\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", " \n", @@ -761,7 +782,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -779,14 +800,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -798,30 +819,54 @@ "for cell_content, (x, y) in model.grid.coord_iter():\n", " agent_count = len(cell_content)\n", " agent_counts[x][y] = agent_count\n", - "# Plot using seaborn, with a size of 5x5\n", + "# Plot using seaborn, with a visual size of 5x5\n", "g = sns.heatmap(agent_counts, cmap=\"viridis\", annot=True, cbar=False, square=True)\n", - "g.figure.set_size_inches(4, 4)\n", + "g.figure.set_size_inches(5, 5)\n", "g.set(title=\"Number of agents on each cell of the grid\");" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Challenge: Change the size of the grid" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Challenge: Change from multigrid to grid (only one agent per cell) " + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Collecting Data\n", + "## Collecting Data\n", "\n", - "So far, at the end of every model run, we've had to go and write our own code to get the data out of the model. This has two problems: it isn't very efficient, and it only gives us end results. If we wanted to know the wealth of each agent at each step, we'd have to add that to the loop of executing steps, and figure out some way to store the data.\n", + "**Background:** So far, at the end of every model run, we've had to go and write our own code to get the data out of the model. This has two problems: it isn't very efficient, and it only gives us end results. If we wanted to know the wealth of each agent at each step, we'd have to add that to the loop of executing steps, and figure out some way to store the data.\n", "\n", "Since one of the main goals of agent-based modeling is generating data for analysis, Mesa provides a class which can handle data collection and storage for us and make it easier to analyze.\n", "\n", - "The data collector stores three categories of data: model-level variables, agent-level variables, and tables (which are a catch-all for everything else). Model- and agent-level variables are added to the data collector along with a function for collecting them. Model-level collection functions take a model object as an input, while agent-level collection functions take an agent object as an input. Both then return a value computed from the model or each agent at their current state. When the data collector’s `collect` method is called, with a model object as its argument, it applies each model-level collection function to the model, and stores the results in a dictionary, associating the current value with the current step of the model. Similarly, the method applies each agent-level collection function to each agent currently in the schedule, associating the resulting value with the step of the model, and the agent’s `unique_id`.\n", + "The data collector stores three categories of data: \n", + " - Model-level variables : Model-level collection functions take a model object as an input. Such as a function that computes a dynamic of the whole model (in this case we will compute a measure of wealth inequality based on all agents wealth)\n", + " - Agent-level variables: Agent-level collection functions take an agent object as an input and is typically the state of an agent attributes, in this case wealth.\n", + " - Tables (which are a catch-all for everything else). \n", + "\n", + "**Model-specific information:** We will collect two variables to show Mesa capabilities. At the model level, let's measure the model's [Gini Coefficient](https://en.wikipedia.org/wiki/Gini_coefficient), a measure of wealth inequality. At the agent level, we want to collect every agent's wealth at every step. \n", "\n", - "Let's add a DataCollector to the model with [`mesa.DataCollector`](https://github.com/projectmesa/mesa/blob/main/mesa/datacollection.py), and collect two variables. At the agent level, we want to collect every agent's wealth at every step. At the model level, let's measure the model's [Gini Coefficient](https://en.wikipedia.org/wiki/Gini_coefficient), a measure of wealth inequality." + "**Code implementation:**\n", + "Let's add a DataCollector to the model with [`mesa.DataCollector`](https://github.com/projectmesa/mesa/blob/main/mesa/datacollection.py), and collect the agents wealth and the gini coefficient at each time step. " ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -903,7 +948,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -919,14 +964,21 @@ "To get the series of Gini coefficients as a pandas DataFrame:" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing a Model Data" + ] + }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -942,6 +994,13 @@ "g.set(title=\"Gini Coefficient over Time\", ylabel=\"Gini Coefficient\");" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing an Agent Data" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -951,7 +1010,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -1020,7 +1079,7 @@ " 5 1" ] }, - "execution_count": 21, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -1039,12 +1098,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1069,17 +1128,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Or to plot the wealth of a given agent (in this example, agent 14):" + "Or to plot the wealth of a given agent (in this example, agent 7):" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1090,11 +1149,11 @@ ], "source": [ "# Get the wealth of agent 14 over time\n", - "one_agent_wealth = agent_wealth.xs(14, level=\"AgentID\")\n", + "one_agent_wealth = agent_wealth.xs(7, level=\"AgentID\")\n", "\n", - "# Plot the wealth of agent 14 over time\n", + "# Plot the wealth of agent 7 over time\n", "g = sns.lineplot(data=one_agent_wealth, x=\"Step\", y=\"Wealth\")\n", - "g.set(title=\"Wealth of agent 14 over time\");" + "g.set(title=\"Wealth of agent 7 over time\");" ] }, { @@ -1106,12 +1165,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1141,7 +1200,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -1150,13 +1209,13 @@ "[Text(0.5, 1.0, 'Average wealth over time')]" ] }, - "execution_count": 25, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1209,9 +1268,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Batch Run\n", + "## Batch Run\n", "\n", - "Like we mentioned above, you usually won't run a model only once, but multiple times, with fixed parameters to find the overall distributions the model generates, and with varying parameters to analyze how they drive the model's outputs and behaviors. Instead of needing to write nested for-loops for each model, Mesa provides a [`batch_run`](https://github.com/projectmesa/mesa/blob/main/mesa/batchrunner.py) function which automates it for you.\n", + "Like we mentioned above, you usually won't run a model only once, but multiple times, with fixed parameters to find the overall distributions the model generates, and with varying parameters to analyze how they drive the model's outputs and behaviors. This is commonly referred to as parameter sweeps. Instead of needing to write nested for-loops for each model, Mesa provides a [`batch_run`](https://github.com/projectmesa/mesa/blob/main/mesa/batchrunner.py) function which automates it for you.\n", "\n", "The batch runner also requires an additional variable `self.running` for the MoneyModel class. This variable enables conditional shut off of the model once a condition is met. In this example it will be set as True indefinitely." ] @@ -1228,7 +1287,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -1304,7 +1363,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Batch run\n", + "#### Batch run parameters\n", "\n", "We call `batch_run` with the following arguments:\n", "\n", @@ -1350,13 +1409,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "71f6949783314c9da5a151f2a9510531", + "model_id": "7a7809d6fd184ced98c151adf994d80b", "version_major": 2, "version_minor": 0 }, @@ -1389,9 +1448,16 @@ "To further analyze the return of the `batch_run` function, we convert the list of dictionaries to a Pandas DataFrame and print its keys." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Batch Run Analysis and Visualization" + ] + }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -1418,12 +1484,12 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 58, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1460,7 +1526,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 59, "metadata": { "collapsed": false, "jupyter": { @@ -1470,7 +1536,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1502,7 +1568,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -1516,11 +1582,11 @@ " 1 3.0 1.0\n", " 1 4.0 1.0\n", " ... ... ...\n", - " 100 6.0 1.0\n", - " 100 7.0 2.0\n", - " 100 8.0 2.0\n", - " 100 9.0 1.0\n", - " 100 10.0 1.0\n" + " 100 6.0 0.0\n", + " 100 7.0 0.0\n", + " 100 8.0 3.0\n", + " 100 9.0 0.0\n", + " 100 10.0 2.0\n" ] } ], @@ -1547,7 +1613,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 61, "metadata": {}, "outputs": [ { @@ -1555,17 +1621,17 @@ "output_type": "stream", "text": [ " Step Gini\n", - " 1 0.00\n", - " 2 0.00\n", + " 1 0.18\n", + " 2 0.18\n", " 3 0.18\n", - " 4 0.18\n", - " 5 0.42\n", + " 4 0.32\n", + " 5 0.32\n", " ... ...\n", - " 96 0.66\n", - " 97 0.66\n", - " 98 0.66\n", - " 99 0.66\n", - " 100 0.66\n" + " 96 0.58\n", + " 97 0.54\n", + " 98 0.54\n", + " 99 0.56\n", + " 100 0.56\n" ] } ], @@ -1591,7 +1657,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 62, "metadata": { "collapsed": false, "jupyter": { @@ -1602,7 +1668,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "60f4353fc39647378e6fd084bef80c1c", + "model_id": "9089656a90b547a890073cbefa30c097", "version_major": 2, "version_minor": 0 }, @@ -1632,7 +1698,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 63, "metadata": { "collapsed": false, "jupyter": { @@ -1729,7 +1795,7 @@ "11 2.0 " ] }, - "execution_count": 37, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" } @@ -1742,7 +1808,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 64, "metadata": { "collapsed": false, "jupyter": { @@ -1752,7 +1818,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1797,7 +1863,7 @@ } }, "source": [ - "### Analyzing agent reporters\n", + "### Analyzing agent reporters: Comparing 5 scenarios\n", "From the agents we collected the wealth and the number of consecutive rounds without a transaction. We can compare the 5 different population sizes by plotting the average number of consecutive rounds without a transaction for each population size.\n", "\n", "Note that we're aggregating multiple times here: First we take the average of all agents for each single replication. Then we plot the averages for all replications, with the error band showing the 95% confidence interval of that first average (over all agents). So this error band is representing the uncertainty of the mean value of the number of consecutive rounds without a transaction for each population size." @@ -1805,7 +1871,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 68, "metadata": { "collapsed": false, "jupyter": { @@ -1877,7 +1943,7 @@ "2 0 5 2 1.0 1.0" ] }, - "execution_count": 39, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -1894,7 +1960,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 69, "metadata": { "collapsed": false, "jupyter": { @@ -1904,7 +1970,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1946,7 +2012,7 @@ } }, "source": [ - "#### General steps for analyzing results\n", + "### General steps for analyzing results\n", "\n", "Many other analysis are possible based on the policies, scenarios and uncertainties that you might be interested in. In general, you can follow these steps to do your own analysis:\n", "\n", @@ -1959,11 +2025,29 @@ "7. Plot the data and analyze the results." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Challenge update the model, conduct a batch run with a parameter sweep, and visualiza your results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Next Steps\n", + "\n", + "Check out the [visualization tutorial](https://mesa.readthedocs.io/latest/tutorials/visualization_tutorial.html) on how to build interactive models in a dashboard" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Happy Modeling!\n", + "## Happy Modeling!\n", "\n", "This document is a work in progress. If you see any errors, exclusions or have any problems please contact [us](https://github.com/projectmesa/mesa/issues)." ] From e18c288da96a8063226bc66fceeb63bf36be080b Mon Sep 17 00:00:00 2001 From: Tom Pike Date: Sun, 20 Oct 2024 07:22:07 -0400 Subject: [PATCH 3/6] intro_tutorial update - add AgentSet functionality section - change N parameter to n to be consistent - improve grammar and readability --- docs/tutorials/MoneyModel.py | 4 +- docs/tutorials/intro_tutorial.ipynb | 1102 ++++++++----------- docs/tutorials/visualization_tutorial.ipynb | 5 +- 3 files changed, 470 insertions(+), 641 deletions(-) diff --git a/docs/tutorials/MoneyModel.py b/docs/tutorials/MoneyModel.py index 576b8e71b13..4d6dc02d59d 100644 --- a/docs/tutorials/MoneyModel.py +++ b/docs/tutorials/MoneyModel.py @@ -49,7 +49,7 @@ def step(self): class MoneyModel(mesa.Model): """A model with some number of agents.""" - def __init__(self, N, width, height, seed=None): + def __init__(self, n, width, height, seed=None): """Initialize a MoneyModel instance. Args: @@ -58,7 +58,7 @@ def __init__(self, N, width, height, seed=None): height: Height of the grid. """ super().__init__(seed=seed) - self.num_agents = N + self.num_agents = n self.grid = mesa.space.MultiGrid(width, height, True) self.schedule = mesa.time.RandomActivation(self) diff --git a/docs/tutorials/intro_tutorial.ipynb b/docs/tutorials/intro_tutorial.ipynb index 35ab9923c1e..c92bf362b32 100644 --- a/docs/tutorials/intro_tutorial.ipynb +++ b/docs/tutorials/intro_tutorial.ipynb @@ -15,21 +15,39 @@ "source": [ "**Important:** \n", "- If you are just exploring Mesa and want the fastest way to execute the code we recommend executing this tutorial online in a Colab notebook. [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/projectmesa/mesa/blob/main/docs/tutorials/intro_tutorial.ipynb)\n", - "- If you have installed mesa and are running locally, please ensure that your Mexa version is greater than or equal to 3.0.0b1.\n", + "- If you have installed mesa and are running locally, please ensure that your Mesa version is greater than or equal to 3.0.0b1.\n", "\n", "## Tutorial Description\n", "\n", - "[Mesa](https://github.com/projectmesa/mesa) is a Python framework for [agent-based modeling](https://en.wikipedia.org/wiki/Agent-based_model). This tutorial will assist you in getting started. Working through the tutorial will help you discover the core features of Mesa. Through the tutorial, you will walk through a starter-level model. Functionality is added progressively as the process unfolds. Should anyone find any errors, bugs, have a suggestion, or just are looking for clarification, let us know in our [chat](https://matrix.to/#/#project-mesa:matrix.org)!\n", + "[Mesa](https://github.com/projectmesa/mesa) is a Python framework for [agent-based modeling](https://en.wikipedia.org/wiki/Agent-based_model). This tutorial will assist you in getting started and discover some of the core features of Mesa. The tutorial starts with the key pieces of a model and then progressively adds functionality. \n", "\n", - "The premise of this tutorial is to create a starter-level model representing agents exchanging money. This exchange of money affects wealth. \n", + "Should anyone find any errors, bugs, have a suggestion, or just are looking for clarification, let us know in our [chat](https://matrix.to/#/#project-mesa:matrix.org)!\n", "\n", - "Next, *space* is added to allow agents to move based on the change in wealth as time progresses.\n", + "The premise of this tutorial is to create a starter-level model representing agents exchanging money. \n", "\n", - "Two of Mesa's analytic tools: the *data collector* and *batch runner* are then used to examine the dynamics of this simple model. \n", + "The table of contents (icon on the left) shows each of the items this tutorial covers with the major sections being: \n", "\n", - "### More Tutorials: \n", + "- Model Description and Set Up\n", + "- Building the Basic Model\n", + "- Adding Space\n", + "- Collecting Data\n", + "- AgentSet Functionality\n", + "- Batch Run " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### More Mesa\n", "\n", - "Visualization: There is a separate [visualization tutorial](https://mesa.readthedocs.io/stable/tutorials/visualization_tutorial.html) that will take users through building a visualization for this model (aka Boltzmann Wealth Model)." + "If you are looking for other Mesa models or tools here are some additional resources. \n", + "\n", + "- Interactive Dashboard: There is a separate [visualization tutorial](https://mesa.readthedocs.io/latest/tutorials/visualization_tutorial.html) that will take users through building a dashboard for this model (aka Boltzmann Wealth Model).\n", + "- Classic ABMs: You can also find canonical examples of ABMs written in Mesa in the [Examples Tab](https://mesa.readthedocs.io/latest/tutorials/examples.html)\n", + "- More Examples: Want to integrate Reinforcement Learning or work on the Traveling Salesman Problem checkout [Mesa Examples](https://github.com/projectmesa/mesa-examples/)\n", + "- Mesa-Geo: If you need an ABM with Geographic Information Systems (GIS) checkout [Mesa-Geo](https://mesa-geo.readthedocs.io/latest/)\n", + "- Mesa Frames: Have a large complex model that you need to speed up, check out [Mesa Frames](https://github.com/projectmesa/mesa-frames)" ] }, { @@ -73,7 +91,7 @@ "pip install --upgrade --pre mesa\n", "```\n", "\n", - "Install Jupyter Notebook (optional):\n", + "Install Jupyter notebook (optional):\n", "\n", "```bash\n", "pip install jupyter\n", @@ -110,7 +128,7 @@ "\n", "After Mesa is installed a model can be built. A jupyter notebook is recommended for this tutorial, this allows for small segments of codes to be examined one at a time. \n", "\n", - "### Creating Model With Jupyter Notebook\n", + "### Creating Model With Jupyter notebook\n", "\n", "Write the model interactively in [Jupyter](http://jupyter.org/) cells.\n", "\n", @@ -120,7 +138,7 @@ "jupyter lab\n", "```\n", "\n", - "Create a new Notebook named `money_model.ipynb` (or whatever you want to call it).\n", + "Create a new notebook named `money_model.ipynb` (or whatever you want to call it).\n", "\n", "### Creating Model With Script File (IDE, Text Editor, Colab, etc.)\n", "\n", @@ -141,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { @@ -182,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -203,7 +221,7 @@ "source": [ "### Create Model\n", "\n", - "Next, create the model. This gives us the two basic classess of any Mesa ABM - the agent class (population of agent objects that doing something) and the manager class (a model object that manages the creation, activation, datacollection etc of the agents)\n", + "Next, create the model. This gives us the two basic classes of any Mesa ABM - the agent class (population of agent objects that doing something) and the manager class (a model object that manages the creation, activation, datacollection etc of the agents)\n", "\n", "**Background:** The model can be visualized as a list containing all the agents. The model creates, holds and manages all the agent objects, specifically in a dictionary. The model activates agents in discrete time steps.\n", "\n", @@ -216,16 +234,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, seed=None):\n", + " def __init__(self, n, seed=None):\n", " super().__init__(seed=seed)\n", - " self.num_agents = N\n", + " self.num_agents = n\n", " # Create agents\n", " for _ in range(self.num_agents):\n", " a = MoneyAgent(self)" @@ -242,14 +260,14 @@ "\n", "**Background:** Mesa's `do` function calls agent functions the grow your ABM. A step is the smallest unit of time in the model, and is often referred to as a tick. The `do` function and Python functionality can be configured to activate agents in different orders. This can be important as the order in which agents are activated can impact the results of the model [Comer2014]. At each step of the model, one or more of the agents -- usually all of them -- are activated and take their own step, changing internally and/or interacting with one another or the environment. A overview of different ways to employ the `do` function for different activation regimes can be found in the [\"How To\" Guide](https://mesa.readthedocs.io/latest/howto.html).\n", "\n", - "**Model-specific information:** For this section we wil randomly reorder the Agent activation order using `mesa.Agent.shuffle_do` and have the agents `step` function print the agent unique id they are assigned during the agent creation process. \n", + "**Model-specific information:** For this section we will randomly reorder the Agent activation order using `mesa.Agent.shuffle_do` and have the agents `step` function print the agent unique id they are assigned during the agent creation process. \n", "\n", "**Code implementation:** Using standard ABM convention we add a `step` function to the `MoneyModel` class which calls the `mesa.Agent.shuffle_do` function. We then pass into `shuffle_do` the parameter \"step\". This tells mesa to look for and execute the `step` function in our MoneyAgent class. " ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -272,13 +290,13 @@ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, seed=None):\n", + " def __init__(self, n, seed=None):\n", " super().__init__(seed=seed)\n", - " self.num_agents = N\n", + " self.num_agents = n\n", " \n", " # Create agents\n", " for _ in range(self.num_agents):\n", - " a = MoneyAgent(self) # This calls the agent class parameter N number of times \n", + " a = MoneyAgent(self) # This calls the agent class parameter n number of times \n", "\n", " def step(self):\n", " \"\"\"Advance the model by one step.\"\"\"\n", @@ -295,7 +313,7 @@ "### Running the Model\n", "A basic model has now been created. The model can be run by creating a model object and calling the step method. The model will run for one step and print the unique_id of each agent. You may run the model for multiple steps by calling the step method multiple times.\n", "\n", - "Note: If you are using `.py` (script) files instead of `.ipynb` (Jupyter), the common convention is\n", + "note: If you are using `.py` (script) files instead of `.ipynb` (Jupyter), the common convention is\n", "to have a `run.py` in the same directory as your model code. You then (1) import the ``MoneyModel`` class,\n", "(2) create a model object and (3) run it for a few steps. As shown below:\n", "\n", @@ -310,26 +328,9 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hi, I am an agent, you can call me 6.\n", - "Hi, I am an agent, you can call me 5.\n", - "Hi, I am an agent, you can call me 4.\n", - "Hi, I am an agent, you can call me 1.\n", - "Hi, I am an agent, you can call me 9.\n", - "Hi, I am an agent, you can call me 3.\n", - "Hi, I am an agent, you can call me 2.\n", - "Hi, I am an agent, you can call me 10.\n", - "Hi, I am an agent, you can call me 8.\n", - "Hi, I am an agent, you can call me 7.\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "starter_model = MoneyModel(10)\n", "starter_model.step()" @@ -337,39 +338,22 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hi, I am an agent, you can call me 6.\n", - "Hi, I am an agent, you can call me 9.\n", - "Hi, I am an agent, you can call me 4.\n", - "Hi, I am an agent, you can call me 8.\n", - "Hi, I am an agent, you can call me 2.\n", - "Hi, I am an agent, you can call me 3.\n", - "Hi, I am an agent, you can call me 5.\n", - "Hi, I am an agent, you can call me 7.\n", - "Hi, I am an agent, you can call me 10.\n", - "Hi, I am an agent, you can call me 1.\n" - ] - } - ], + "outputs": [], "source": [ - "# Run this step a few times and see what happens! Notice the order of the agents changes each time.\n", + "# Run this step a few times and see what happens! notice the order of the agents changes each time.\n", "starter_model.step()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -378,7 +362,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -395,7 +379,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { @@ -416,7 +400,7 @@ "\n", " def step(self):\n", " # The agent's step will go here.\n", - " # FIXME: Need to print the agent's wealth\n", + " # FIXME: need to print the agent's wealth\n", " print(f\"Hi, I am an agent and I am broke!\")" ] }, @@ -429,7 +413,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { @@ -443,7 +427,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -469,7 +453,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -500,23 +484,23 @@ "\n", "With that last piece in hand, it's time for the first rudimentary run of the model.\n", "\n", - "If you've written the code in its own script file (`money_model.py` or a different name) you can now modify your ``run.py`` or even launch a Jupyter Notebook. You then just follow the same three steps of (1) import your model class ``MoneyModel``, (2) create the model object and (3) run it for a few steps. If you wrote the code in one Notebook then step 1, importing, is not necessary.\n", + "If you've written the code in its own script file (`money_model.py` or a different name) you can now modify your ``run.py`` or even launch a Jupyter notebook. You then just follow the same three steps of (1) import your model class ``MoneyModel``, (2) create the model object and (3) run it for a few steps. If you wrote the code in one notebook then step 1, importing, is not necessary.\n", "\n", "```python\n", "from money_model import MoneyModel\n", "```\n", "\n", - "Now let's create a model with 10 agents, and run it for 10 steps." + "now let's create a model with 10 agents, and run it for 10 steps." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "model = MoneyModel(10) # Tels the model to create 10 agents\n", - "for _ in range(10): #Runs the model for 10 steps; an underscore is common convetion for a variable that is not used\n", + "for _ in range(10): #Runs the model for 10 steps; an underscore is common convention for a variable that is not used\n", " model.step()" ] }, @@ -524,31 +508,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Next, we need to get some data out of the model. Specifically, we want to see the distribution of the agent's wealth. We can get the wealth values with list comprehension, and then use seaborn (or another graphics library) to visualize the data in a histogram." + "next, we need to get some data out of the model. Specifically, we want to see the distribution of the agent's wealth. We can get the wealth values with list comprehension, and then use seaborn (or another graphics library) to visualize the data in a histogram." ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "agent_wealth = [a.wealth for a in model.agents]\n", "# Create a histogram with seaborn\n", "g = sns.histplot(agent_wealth, discrete=True)\n", "g.set(\n", - " title=\"Wealth distribution\", xlabel=\"Wealth\", ylabel=\"Number of agents\"\n", + " title=\"Wealth distribution\", xlabel=\"Wealth\", ylabel=\"number of agents\"\n", "); # The semicolon is just to avoid printing the object representation" ] }, @@ -568,20 +541,9 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "all_wealth = []\n", "# This runs the model 100 times, each model executing 10 steps.\n", @@ -597,14 +559,14 @@ "\n", "# Use seaborn\n", "g = sns.histplot(all_wealth, discrete=True)\n", - "g.set(title=\"Wealth distribution\", xlabel=\"Wealth\", ylabel=\"Number of agents\");" + "g.set(title=\"Wealth distribution\", xlabel=\"Wealth\", ylabel=\"number of agents\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "This runs 100 instantiations of the model, and runs each for 10 steps. (Notice that we set the histogram bins to be integers, since agents can only have whole numbers of wealth). This distribution looks a lot smoother. By running the model 100 times, we smooth out some of the 'noise' of randomness, and get to the model's overall expected behavior.\n", + "This runs 100 instantiations of the model, and runs each for 10 steps. (notice that we set the histogram bins to be integers, since agents can only have whole numbers of wealth). This distribution looks a lot smoother. By running the model 100 times, we smooth out some of the 'noise' of randomness, and get to the model's overall expected behavior.\n", "\n", "This outcome might be surprising. Despite the fact that all agents, on average, give and receive one unit of money every step, the model converges to a state where most agents have a small amount of money and a small number have a lot of money." ] @@ -623,7 +585,7 @@ "\n", "**Model-specific information:** Let's add a simple spatial element to our model by putting our agents on a grid and make them walk around at random. Instead of giving their unit of money to any random agent, they'll give it to an agent on the same cell. For the Money model multiple agents can be in the same spaces and since they are on a torus the agents on the left side can exchange money with agent on the right. Agents on the top can exchange with agents on the bottom.\n", "\n", - "**Code Implementation:** We get a random integer within the width and height of the grid space and the use Mesa's multigrid `place_agent` function to place the agent in the specificed grid location." + "**Code Implementation:** We get a random integer within the width and height of the grid space and the use Mesa's multigrid `place_agent` function to place the agent in the specified grid location." ] }, { @@ -635,16 +597,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, width, height, seed=None):\n", + " def __init__(self, n, width, height, seed=None):\n", " super().__init__(seed=seed)\n", - " self.num_agents = N\n", + " self.num_agents = n\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", "\n", " # Create agents\n", @@ -677,7 +639,7 @@ " neighbors.append((x+dx, y+dy))\n", "```\n", "\n", - "But there's an even simpler way, using the grid's built-in `get_neighborhood` method, which returns all the neighbors of a given cell. This method can get two types of cell neighborhoods: [Moore](https://en.wikipedia.org/wiki/Moore_neighborhood) (includes all 8 surrounding squares), and [Von Neumann](https://en.wikipedia.org/wiki/Von_Neumann_neighborhood)(only up/down/left/right). It also needs an argument as to whether to include the center cell itself as one of the neighbors.\n", + "But there's an even simpler way, using the grid's built-in `get_neighborhood` method, which returns all the neighbors of a given cell. This method can get two types of cell neighborhoods: [Moore](https://en.wikipedia.org/wiki/Moore_neighborhood) (includes all 8 surrounding squares), and [Von neumann](https://en.wikipedia.org/wiki/Von_neumann_neighborhood)(only up/down/left/right). It also needs an argument as to whether to include the center cell itself as one of the neighbors.\n", "\n", "With that in mind, the agent's `move` method looks like this:\n", "\n", @@ -722,7 +684,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -756,9 +718,9 @@ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, width, height,seed=None):\n", + " def __init__(self, n, width, height,seed=None):\n", " super().__init__(seed=seed)\n", - " self.num_agents = N\n", + " self.num_agents = n\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", " \n", " # Create agents\n", @@ -782,7 +744,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -795,25 +757,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's use seaborn and numpy to visualize the number of agents residing in each cell. To do that, we create a numpy array of the same size as the grid, filled with zeros. Then we use the grid object's `coord_iter()` feature, which lets us loop over every cell in the grid, giving us each cell's positions and contents in turn." + "now let's use seaborn and numpy to visualize the number of agents residing in each cell. To do that, we create a numpy array of the same size as the grid, filled with zeros. Then we use the grid object's `coord_iter()` feature, which lets us loop over every cell in the grid, giving us each cell's positions and contents in turn." ] }, { "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "agent_counts = np.zeros((model.grid.width, model.grid.height))\n", "for cell_content, (x, y) in model.grid.coord_iter():\n", @@ -822,12 +773,12 @@ "# Plot using seaborn, with a visual size of 5x5\n", "g = sns.heatmap(agent_counts, cmap=\"viridis\", annot=True, cbar=False, square=True)\n", "g.figure.set_size_inches(5, 5)\n", - "g.set(title=\"Number of agents on each cell of the grid\");" + "g.set(title=\"number of agents on each cell of the grid\");" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -836,7 +787,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -866,16 +817,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def compute_gini(model):\n", " agent_wealths = [agent.wealth for agent in model.agents]\n", " x = sorted(agent_wealths)\n", - " N = model.num_agents\n", - " B = sum(xi * (N - i) for i, xi in enumerate(x)) / (N * sum(x))\n", - " return 1 + (1 / N) - 2 * B\n", + " n = model.num_agents\n", + " B = sum(xi * (n - i) for i, xi in enumerate(x)) / (n * sum(x))\n", + " return 1 + (1 / n) - 2 * B\n", "\n", "\n", "class MoneyAgent(mesa.Agent):\n", @@ -902,7 +853,7 @@ " other.wealth += 1\n", " self.wealth -= 1\n", " if other == self:\n", - " print(\"I JUST GAVE MONEY TO MYSELF HEHEHE!\")\n", + " print(\"I JUST GAVE MOnEY TO MYSELF HEHEHE!\")\n", "\n", " def step(self):\n", " self.move()\n", @@ -913,9 +864,9 @@ "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, width, height):\n", + " def __init__(self, n, width, height):\n", " super().__init__()\n", - " self.num_agents = N\n", + " self.num_agents = n\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", "\n", " # Create agents\n", @@ -941,14 +892,14 @@ "source": [ "At every step of the model, the datacollector will collect and store the model-level current Gini coefficient, as well as each agent's wealth, associating each with the current step.\n", "\n", - "We run the model just as we did above. Now is when an interactive session, especially via a Notebook, comes in handy: the DataCollector can export the data its collected as a pandas* DataFrame, for easy interactive analysis. \n", + "We run the model just as we did above. now is when an interactive session, especially via a notebook, comes in handy: the DataCollector can export the data its collected as a pandas* DataFrame, for easy interactive analysis. \n", "\n", "*If you are new to Python, please be aware that pandas is already installed as a dependency of Mesa and that [pandas](https://pandas.pydata.org/docs/) is a \"fast, powerful, flexible and easy to use open source data analysis and manipulation tool\". pandas is great resource to help analyze the data collected in your models." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -973,20 +924,9 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "gini = model.datacollector.get_model_vars_dataframe()\n", "# Plot the Gini coefficient over time\n", @@ -1010,80 +950,9 @@ }, { "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Wealth
StepAgentID
111
21
31
41
51
\n", - "
" - ], - "text/plain": [ - " Wealth\n", - "Step AgentID \n", - "1 1 1\n", - " 2 1\n", - " 3 1\n", - " 4 1\n", - " 5 1" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "agent_wealth = model.datacollector.get_agent_vars_dataframe()\n", "agent_wealth.head()" @@ -1098,20 +967,9 @@ }, { "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "last_step = agent_wealth.index.get_level_values(\"Step\").max()\n", "end_wealth = agent_wealth.xs(last_step, level=\"Step\")[\"Wealth\"]\n", @@ -1120,7 +978,7 @@ "g.set(\n", " title=\"Distribution of wealth at the end of simulation\",\n", " xlabel=\"Wealth\",\n", - " ylabel=\"Number of agents\",\n", + " ylabel=\"number of agents\",\n", ");" ] }, @@ -1133,20 +991,9 @@ }, { "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Get the wealth of agent 14 over time\n", "one_agent_wealth = agent_wealth.xs(7, level=\"AgentID\")\n", @@ -1165,20 +1012,9 @@ }, { "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "agent_list = [3, 14, 25]\n", "\n", @@ -1200,30 +1036,9 @@ }, { "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[Text(0.5, 1.0, 'Average wealth over time')]" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Transform the data to a long format\n", "agent_wealth_long = agent_wealth.T.unstack().reset_index()\n", @@ -1264,6 +1079,289 @@ "agent_wealth.to_csv(\"agent_data.csv\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## AgentSet Functionality\n", + "\n", + "**Background:** With Mesa's AgentSet approach users can also [manage agents](https://mesa.readthedocs.io/latest/overview.html#agentset-and-model-agents) in several ways. \n", + "\n", + "**Model-specific information:** We will show three agent management techniques just to demonstrate the capability\n", + "1. **Applying Methods** We will shuffle the agents and move them and then have them exchange money without reordering them\n", + "2. **Selecting** We will institute a policy that has the rich agents give money to the poor agents\n", + "3. **GroupBy** We will group agents together based on wealth" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Applying Methods\n", + "\n", + "**Code Implementation** In this variation we accomplish the same process using the AgentSet features. We remove the step function entirely, shuffle the agent order have them execute the `move` function. Then we have them execute the `give_money` function to get a similar result as we saw in the Adding Space Section. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class MoneyAgent(mesa.Agent):\n", + " \"\"\"An agent with fixed initial wealth.\"\"\"\n", + "\n", + " def __init__(self, model):\n", + " super().__init__(model)\n", + " self.wealth = 1\n", + "\n", + " def move(self):\n", + " possible_steps = self.model.grid.get_neighborhood(\n", + " self.pos, moore=True, include_center=False\n", + " )\n", + " new_position = self.random.choice(possible_steps)\n", + " self.model.grid.move_agent(self, new_position)\n", + "\n", + " def give_money(self):\n", + " if self.wealth > 0: \n", + " cellmates = self.model.grid.get_cell_list_contents([self.pos])\n", + " if len(cellmates) > 1:\n", + " other_agent = self.random.choice(cellmates)\n", + " other_agent.wealth += 1\n", + " self.wealth -= 1\n", + " \n", + "\n", + "class MoneyModel(mesa.Model):\n", + " \"\"\"A model with some number of agents.\"\"\"\n", + "\n", + " def __init__(self, n, width, height,seed=None):\n", + " super().__init__(seed=seed)\n", + " self.num_agents = n\n", + " self.grid = mesa.space.MultiGrid(width, height, True)\n", + " \n", + " # Create agents\n", + " for _ in range(self.num_agents):\n", + " a = MoneyAgent(self)\n", + " # Add the agent to a random grid cell\n", + " x = self.random.randrange(self.grid.width)\n", + " y = self.random.randrange(self.grid.height)\n", + " self.grid.place_agent(a, (x, y))\n", + "\n", + " self.datacollector = mesa.DataCollector(\n", + " model_reporters={\"Gini\": compute_gini}, agent_reporters={\"Wealth\": \"wealth\"}\n", + " )\n", + "\n", + " def step(self):\n", + " self.datacollector.collect(self)\n", + " self.agents.shuffle_do(\"move\")\n", + " self.agents.do(\"give_money\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we set up our model object and run it for 20 steps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = MoneyModel(100, 10, 10)\n", + "for _ in range(20):\n", + " model.step()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we plot our model result on the grid" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "agent_counts = np.zeros((model.grid.width, model.grid.height))\n", + "for cell_content, (x, y) in model.grid.coord_iter():\n", + " agent_count = len(cell_content)\n", + " agent_counts[x][y] = agent_count\n", + "# Plot using seaborn, with a visual size of 5x5\n", + "g = sns.heatmap(agent_counts, cmap=\"viridis\", annot=True, cbar=False, square=True)\n", + "g.figure.set_size_inches(5, 5)\n", + "g.set(title=\"Number of agents on each cell of the grid\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Selecting \n", + "\n", + "**Model-specific Information:** For this variation of the model we are going to institute a policy that rich agents give money to poor agent\n", + "\n", + "**Code Implementation:** We will use `agents.select` to separate the agents into rich and poor agents. If there are rich agents then they are the only ones who give money. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class MoneyAgent(mesa.Agent):\n", + " \"\"\"An agent with fixed initial wealth.\"\"\"\n", + "\n", + " def __init__(self, model):\n", + " super().__init__(model)\n", + " self.wealth = 1\n", + "\n", + " def give_money(self, poor_agents):\n", + " if self.wealth > 0: \n", + " other_agent = self.random.choice(poor_agents)\n", + " other_agent.wealth += 1\n", + " self.wealth -= 1\n", + " \n", + "\n", + "class MoneyModel(mesa.Model):\n", + " \"\"\"A model with some number of agents.\"\"\"\n", + "\n", + " def __init__(self, n):\n", + " super().__init__()\n", + " self.num_agents = n\n", + " \n", + " # Create agents\n", + " for _ in range(self.num_agents):\n", + " a = MoneyAgent(self)\n", + "\n", + " self.datacollector = mesa.DataCollector(\n", + " model_reporters={\"Gini\": compute_gini}, agent_reporters={\"Wealth\": \"wealth\"}\n", + " )\n", + " \n", + " def step(self):\n", + " self.datacollector.collect(self)\n", + " # Get lists of rich and poor agents\n", + " rich_agents = model.agents.select(lambda a: a.wealth >= 3)\n", + " poor_agents = model.agents.select(lambda a: a.wealth < 3)\n", + " # When there is rich agents only have them give money to the poor agents\n", + " if len(rich_agents) > 0: \n", + " rich_agents.shuffle_do(\"give_money\", poor_agents)\n", + " else: \n", + " poor_agents.shuffle_do(\"give_money\", poor_agents) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now run the model, collect the data, and plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = MoneyModel(100)\n", + "for _ in range(20):\n", + " model.step() \n", + "\n", + "\n", + "data = model.datacollector.get_agent_vars_dataframe()\n", + "# Use seaborn\n", + "g = sns.histplot(data[\"Wealth\"], discrete=True)\n", + "g.set(title=\"Wealth distribution\", xlabel=\"Wealth\", ylabel=\"number of agents\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Group By \n", + "\n", + "**Model-specific implementation:** In this case we will give agents an attribute of enthnicity of Green, Blue or Mixed. Green and Blue agents only give money to their ethnicity while Mixed can give money to anyone.\n", + "\n", + "**Code Implementation**: Using `groupby` we will execute the above logic in our code passing a list of grouped agents into our `give_money` function. To ensure we can plot wealth by group we also need to add ethnicity to our datacollector. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class MoneyAgent(mesa.Agent):\n", + " \"\"\"An agent with fixed initial wealth.\"\"\"\n", + "\n", + " def __init__(self, model, ethnicity):\n", + " super().__init__(model)\n", + " self.wealth = 1\n", + " self.ethnicity = ethnicity\n", + "\n", + " def give_money(self, similars):\n", + " if self.wealth > 0: \n", + " other_agent = self.random.choice(similars)\n", + " other_agent.wealth += 1\n", + " self.wealth -= 1\n", + " \n", + "\n", + "class MoneyModel(mesa.Model):\n", + " \"\"\"A model with some number of agents.\"\"\"\n", + "\n", + " def __init__(self, n):\n", + " super().__init__()\n", + " self.num_agents = n\n", + " \n", + " # Create a list of our different ethnicities\n", + " ethnicities = [\"Green\", \"Blue\", \"Mixed\"]\n", + " \n", + " # Create agents\n", + " for _ in range(self.num_agents):\n", + " a = MoneyAgent(self, self.random.choice(ethnicities))\n", + "\n", + " self.datacollector = mesa.DataCollector(\n", + " model_reporters={\"Gini\": compute_gini}, agent_reporters={\"Wealth\": \"wealth\", \"Ethnicity\":\"ethnicity\"}\n", + " )\n", + " \n", + " def step(self):\n", + " self.datacollector.collect(self)\n", + " # groupby returns a dictionary of the different ethnicities with a list of agents\n", + " grouped_agents = grouped_agents = model.agents.groupby(\"ethnicity\")\n", + "\n", + " for ethnic, similars in grouped_agents: \n", + " if ethnic != \"Mixed\": \n", + " similars.shuffle_do(\"give_money\", similars)\n", + " else: \n", + " similars.shuffle_do(\"give_money\", self.agents) # This allows mixed to trade with anyone \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the model\n", + "model = MoneyModel(100)\n", + "for _ in range(20):\n", + " model.step()\n", + " \n", + "# get the data\n", + "data = model.datacollector.get_agent_vars_dataframe()\n", + "# assign histogram colors\n", + "palette = {'Green': 'green', 'Blue': 'blue', 'Mixed': 'purple'} \n", + "sns.histplot(data=data, x='Wealth', hue='Ethnicity',discrete=True, palette=palette)\n", + "g.set(title=\"Wealth distribution\", xlabel=\"Wealth\", ylabel=\"number of agents\");" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1287,24 +1385,24 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def compute_gini(model):\n", " agent_wealths = [agent.wealth for agent in model.agents]\n", " x = sorted(agent_wealths)\n", - " N = model.num_agents\n", - " B = sum(xi * (N - i) for i, xi in enumerate(x)) / (N * sum(x))\n", - " return 1 + (1 / N) - 2 * B\n", + " n = model.num_agents\n", + " B = sum(xi * (n - i) for i, xi in enumerate(x)) / (n * sum(x))\n", + " return 1 + (1 / n) - 2 * B\n", "\n", "\n", "class MoneyModel(mesa.Model):\n", " \"\"\"A model with some number of agents.\"\"\"\n", "\n", - " def __init__(self, N, width, height):\n", - " super().__init__()\n", - " self.num_agents = N\n", + " def __init__(self, n, width, height, seed=None):\n", + " super().__init__(seed=seed)\n", + " self.num_agents = n\n", " self.grid = mesa.space.MultiGrid(width, height, True)\n", " self.running = True\n", "\n", @@ -1370,10 +1468,10 @@ "* `model_cls`\n", " The model class that is used for the batch run.\n", "* `parameters`\n", - " A dictionary containing all the parameters of the model class and desired values to use for the batch run as key-value pairs. Each value can either be fixed ( e.g. `{\"height\": 10, \"width\": 10}`) or an iterable (e.g. `{\"N\": range(10, 500, 10)}`). `batch_run` will then generate all possible parameter combinations based on this dictionary and run the model `iterations` times for each combination.\n", + " A dictionary containing all the parameters of the model class and desired values to use for the batch run as key-value pairs. Each value can either be fixed ( e.g. `{\"height\": 10, \"width\": 10}`) or an iterable (e.g. `{\"n\": range(10, 500, 10)}`). `batch_run` will then generate all possible parameter combinations based on this dictionary and run the model `iterations` times for each combination.\n", "* `number_processes`\n", " If not specified, defaults to 1. Set it to `None` to use all the available processors.\n", - " Note: Multiprocessing does make debugging challenging. If your parameter sweeps are resulting in unexpected errors set `number_processes=1`.\n", + " note: Multiprocessing does make debugging challenging. If your parameter sweeps are resulting in unexpected errors set `number_processes=1`.\n", "* `iterations`\n", " The number of iterations to run each parameter combination for. Optional. If not specified, defaults to 1.\n", "* `data_collection_period`\n", @@ -1397,38 +1495,23 @@ "\n", "**Important:** Since for the latter changes at each time step might be interesting, we set `data_collection_period=1`. By default, it only collects data at the end of each episode.\n", "\n", - "Note: The total number of runs is 245 (= 49 different populations * 5 iterations per population). However, the resulting list of dictionaries will be of length 6186250 (= 250 average agents per population * 49 different populations * 5 iterations per population * 101 steps per iteration). " + "note: The total number of runs is 245 (= 49 different populations * 5 iterations per population). However, the resulting list of dictionaries will be of length 6186250 (= 250 average agents per population * 49 different populations * 5 iterations per population * 101 steps per iteration). " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**Note for Windows OS users:** If you are running this tutorial in Jupyter, make sure that you set `number_processes = 1` (single process). If `number_processes` is greater than 1, it is less straightforward to set up. You can read [Mesa's how-to guide](https://github.com/projectmesa/mesa/blob/main/docs/howto.md), in 'Using multi-process `batch_run` on Windows' section for how to do it." + "**note for Windows OS users:** If you are running this tutorial in Jupyter, make sure that you set `number_processes = 1` (single process). If `number_processes` is greater than 1, it is less straightforward to set up. You can read [Mesa's how-to guide](https://github.com/projectmesa/mesa/blob/main/docs/howto.md), in 'Using multi-process `batch_run` on Windows' section for how to do it." ] }, { "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7a7809d6fd184ced98c151adf994d80b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/133 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Filter the results to only contain the data of one agent (the Gini coefficient will be the same for the entire population at any time) at the 100th step of each episode\n", "results_filtered = results_df[(results_df.AgentID == 1) & (results_df.Step == 100)]\n", - "results_filtered[[\"iteration\", \"N\", \"Gini\"]].reset_index(\n", + "results_filtered[[\"iteration\", \"n\", \"Gini\"]].reset_index(\n", " drop=True\n", ").head() # Create a scatter plot\n", - "g = sns.scatterplot(data=results_filtered, x=\"N\", y=\"Gini\")\n", + "g = sns.scatterplot(data=results_filtered, x=\"n\", y=\"Gini\")\n", "g.set(\n", - " xlabel=\"Number of agents\",\n", + " xlabel=\"number of agents\",\n", " ylabel=\"Gini coefficient\",\n", " title=\"Gini coefficient vs. number of agents\",\n", ");" @@ -1526,31 +1588,20 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Create a point plot with error bars\n", - "g = sns.pointplot(data=results_filtered, x=\"N\", y=\"Gini\", linestyle='none')\n", + "g = sns.pointplot(data=results_filtered, x=\"n\", y=\"Gini\", linestyle='None')\n", "g.figure.set_size_inches(8, 4)\n", "g.set(\n", - " xlabel=\"Number of agents\",\n", + " xlabel=\"number of agents\",\n", " ylabel=\"Gini coefficient\",\n", " title=\"Gini coefficient vs. number of agents\",\n", ");" @@ -1563,43 +1614,24 @@ "Second, we want to display the agent's wealth at each time step of one specific episode. To do this, we again filter our large data frame, this time with a fixed number of agents and only for a specific iteration of that population.\n", "To print the results, we convert the filtered data frame to a string specifying the desired columns to print. \n", "\n", - "Pandas has built-in functions to convert to a lot of different data formats. For example, to display as a table in a Jupyter Notebook, we can use the `to_html()` function which takes the same arguments as `to_string()` (see commented lines)." + "Pandas has built-in functions to convert to a lot of different data formats. For example, to display as a table in a Jupyter notebook, we can use the `to_html()` function which takes the same arguments as `to_string()` (see commented lines)." ] }, { "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Step AgentID Wealth\n", - " 0 NaN NaN\n", - " 1 1.0 1.0\n", - " 1 2.0 1.0\n", - " 1 3.0 1.0\n", - " 1 4.0 1.0\n", - " ... ... ...\n", - " 100 6.0 0.0\n", - " 100 7.0 0.0\n", - " 100 8.0 3.0\n", - " 100 9.0 0.0\n", - " 100 10.0 2.0\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# First, we filter the results\n", - "one_episode_wealth = results_df[(results_df.N == 10) & (results_df.iteration == 2)]\n", + "one_episode_wealth = results_df[(results_df.n == 10) & (results_df.iteration == 2)]\n", "# Then, print the columns of interest of the filtered data frame\n", "print(\n", " one_episode_wealth.to_string(\n", " index=False, columns=[\"Step\", \"AgentID\", \"Wealth\"], max_rows=10\n", " )\n", ")\n", - "# For a prettier display we can also convert the data frame to html, uncomment to test in a Jupyter Notebook\n", + "# For a prettier display we can also convert the data frame to html, uncomment to test in a Jupyter notebook\n", "# from IPython.display import display, HTML\n", "# display(HTML(one_episode_wealth.to_html(index=False, columns=['Step', 'AgentID', 'Wealth'], max_rows=25)))" ] @@ -1613,31 +1645,12 @@ }, { "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Step Gini\n", - " 1 0.18\n", - " 2 0.18\n", - " 3 0.18\n", - " 4 0.32\n", - " 5 0.32\n", - " ... ...\n", - " 96 0.58\n", - " 97 0.54\n", - " 98 0.54\n", - " 99 0.56\n", - " 100 0.56\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "results_one_episode = results_df[\n", - " (results_df.N == 10) & (results_df.iteration == 1) & (results_df.AgentID == 1)\n", + " (results_df.n == 10) & (results_df.iteration == 1) & (results_df.AgentID == 1)\n", "]\n", "print(results_one_episode.to_string(index=False, columns=[\"Step\", \"Gini\"], max_rows=10))" ] @@ -1652,36 +1665,27 @@ }, "source": [ "### Analyzing model reporters: Comparing 5 scenarios\n", - "Other insights might be gathered when we compare the Gini coefficient of different scenarios. For example, we can compare the Gini coefficient of a population with 25 agents to the Gini coefficient of a population with 400 agents. While doing this, we increase the number of iterations to 25 to get a better estimate of the Gini coefficient for each population size and get usable error estimations." + "Other insights might be gathered when we compare the Gini coefficient of different scenarios. For example, we can compare the Gini coefficient of a population with 25 agents to the Gini coefficient of a population with 400 agents. While doing this, we increase the number of iterations to 25 to get a better estimate of the Gini coefficient for each population size and get usable error estimations.\n", + "\n", + "As we look varying the parameters to see the impact on model outcomes, it is critical to again point that users can set the random seed. Due to the often inherent randomness with ABMs the seed becomes crucial for: \n", + "- **Reproducibility** - Being able to replicate the ABM results\n", + "- **Sensitivity Analysis** - Identifying how sensitive/robust your model results are to random fluctuations\n", + "\n", + "Treating the seed as an additional parameter and running numerous scenarios allows us to see the impact of randomness on this model. " ] }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9089656a90b547a890073cbefa30c097", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/500 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
RunIditerationStepwidthheightNGiniAgentIDWealthSteps_not_given
1001101050.01.01.00.0
6002101050.01.01.01.0
11003101050.01.01.02.0
\n", - "" - ], - "text/plain": [ - " RunId iteration Step width height N Gini AgentID Wealth \\\n", - "1 0 0 1 10 10 5 0.0 1.0 1.0 \n", - "6 0 0 2 10 10 5 0.0 1.0 1.0 \n", - "11 0 0 3 10 10 5 0.0 1.0 1.0 \n", - "\n", - " Steps_not_given \n", - "1 0.0 \n", - "6 1.0 \n", - "11 2.0 " - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Again filter the results to only contain the data of one agent (the Gini coefficient will be the same for the entire population at any time)\n", "results_5s_df_filtered = results_5s_df[(results_5s_df.AgentID == 1)]\n", @@ -1808,32 +1718,21 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Create a lineplot with error bars\n", "g = sns.lineplot(\n", " data=results_5s_df,\n", " x=\"Step\",\n", " y=\"Gini\",\n", - " hue=\"N\",\n", + " hue=\"n\",\n", " errorbar=(\"ci\", 95),\n", " palette=\"tab10\",\n", ")\n", @@ -1854,6 +1753,15 @@ "In this case it looks like the Gini coefficient increases slower for smaller populations. This can be because of different things, either because the Gini coefficient is a measure of inequality and the smaller the population, the more likely it is that the agents are all in the same wealth class, or because there are less interactions between agents in smaller populations, which means that the wealth of an agent is less likely to change." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Challenge: Treat the seed as a parameter and see the impact on the Gini Coefficient. You can also plot the seeds against the Gini Coefficient by changing the \"hue\" parameter in sns.lineplot function. " + ] + }, { "cell_type": "markdown", "metadata": { @@ -1871,87 +1779,18 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
iterationNStepWealthSteps_not_given
0050NaNNaN
10511.00.0
20521.01.0
\n", - "
" - ], - "text/plain": [ - " iteration N Step Wealth Steps_not_given\n", - "0 0 5 0 NaN NaN\n", - "1 0 5 1 1.0 0.0\n", - "2 0 5 2 1.0 1.0" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Calculate the mean of the wealth and the number of consecutive rounds for all agents in each episode\n", "agg_results_df = (\n", - " results_5s_df.groupby([\"iteration\", \"N\", \"Step\"])\n", + " results_5s_df.groupby([\"iteration\", \"n\", \"Step\"])\n", " .agg({\"Wealth\": \"mean\", \"Steps_not_given\": \"mean\"})\n", " .reset_index()\n", ")\n", @@ -1960,29 +1799,18 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Create a line plot with error bars\n", "g = sns.lineplot(\n", - " data=agg_results_df, x=\"Step\", y=\"Steps_not_given\", hue=\"N\", palette=\"tab10\"\n", + " data=agg_results_df, x=\"Step\", y=\"Steps_not_given\", hue=\"n\", palette=\"tab10\"\n", ")\n", "g.figure.set_size_inches(8, 4)\n", "g.set(\n", @@ -2031,7 +1859,7 @@ "metadata": {}, "outputs": [], "source": [ - "# Challenge update the model, conduct a batch run with a parameter sweep, and visualiza your results" + "# Challenge update the model, conduct a batch run with a parameter sweep, and visualize your results" ] }, { @@ -2040,7 +1868,7 @@ "source": [ "## Next Steps\n", "\n", - "Check out the [visualization tutorial](https://mesa.readthedocs.io/latest/tutorials/visualization_tutorial.html) on how to build interactive models in a dashboard" + "Check out the [visualization tutorial](https://mesa.readthedocs.io/latest/tutorials/visualization_tutorial.html) on how to build interactive dashboards for your models." ] }, { diff --git a/docs/tutorials/visualization_tutorial.ipynb b/docs/tutorials/visualization_tutorial.ipynb index 1ae055c22b9..eab52ef2dc8 100644 --- a/docs/tutorials/visualization_tutorial.ipynb +++ b/docs/tutorials/visualization_tutorial.ipynb @@ -42,6 +42,7 @@ "outputs": [], "source": [ "# Install and import the latest Mesa pre-release version\n", + "%pip install solara # Prevents from installing solara pre-release\n", "%pip install --quiet --upgrade --pre mesa\n", "import mesa\n", "print(f\"Mesa version: {mesa.__version__}\")\n", @@ -273,7 +274,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -287,7 +288,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.6" + "version": "3.12.5" }, "nbsphinx": { "execute": "never" From 82746ba5e0ff19f0ef12af3528427e88f9d9dfd3 Mon Sep 17 00:00:00 2001 From: Tom Pike Date: Sun, 20 Oct 2024 07:34:45 -0400 Subject: [PATCH 4/6] fix build fail error --- docs/tutorials/intro_tutorial.ipynb | 6 ++---- docs/tutorials/visualization_tutorial.ipynb | 6 ++---- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/docs/tutorials/intro_tutorial.ipynb b/docs/tutorials/intro_tutorial.ipynb index c92bf362b32..3fb6f340298 100644 --- a/docs/tutorials/intro_tutorial.ipynb +++ b/docs/tutorials/intro_tutorial.ipynb @@ -108,12 +108,10 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "raw", "metadata": {}, - "outputs": [], "source": [ - "# SKIP THIS CELL unless running in colab\n", + "# SKIP THIS CELL unless you need to install Mesa; convert cell type from raw to code\n", "\n", "%pip install --quiet --upgrade --pre mesa\n", "print(f\"Mesa version: {mesa.__version__}\")\n", diff --git a/docs/tutorials/visualization_tutorial.ipynb b/docs/tutorials/visualization_tutorial.ipynb index eab52ef2dc8..61ab04cc9cd 100644 --- a/docs/tutorials/visualization_tutorial.ipynb +++ b/docs/tutorials/visualization_tutorial.ipynb @@ -34,14 +34,12 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "raw", "metadata": { "tags": [] }, - "outputs": [], "source": [ - "# Install and import the latest Mesa pre-release version\n", + "# Install and import the latest Mesa pre-release version; convert cell type from raw to code\n", "%pip install solara # Prevents from installing solara pre-release\n", "%pip install --quiet --upgrade --pre mesa\n", "import mesa\n", From 04e99a946c785473a119b85e3880b5f0e57d3b37 Mon Sep 17 00:00:00 2001 From: Tom Pike Date: Sun, 20 Oct 2024 08:05:21 -0400 Subject: [PATCH 5/6] Update visualization_tutorial.ipynb - Fix build failure - Make portions independent to avoid computational overhead --- docs/tutorials/visualization_tutorial.ipynb | 180 +++++++++++++++++--- 1 file changed, 159 insertions(+), 21 deletions(-) diff --git a/docs/tutorials/visualization_tutorial.ipynb b/docs/tutorials/visualization_tutorial.ipynb index 61ab04cc9cd..0957f6b6dfa 100644 --- a/docs/tutorials/visualization_tutorial.ipynb +++ b/docs/tutorials/visualization_tutorial.ipynb @@ -41,13 +41,7 @@ "source": [ "# Install and import the latest Mesa pre-release version; convert cell type from raw to code\n", "%pip install solara # Prevents from installing solara pre-release\n", - "%pip install --quiet --upgrade --pre mesa\n", - "import mesa\n", - "print(f\"Mesa version: {mesa.__version__}\")\n", - "\n", - "# You can either define the BoltzmannWealthModel (aka MoneyModel) or install it\n", - "\n", - "from mesa.examples import BoltzmannWealthModel" + "%pip install --quiet --upgrade --pre mesa\n" ] }, { @@ -57,6 +51,29 @@ "Mesa's grid visualizer works by looping over every cell in a grid, and generating a portrayal for every agent it finds. A portrayal is a dictionary (which can easily be turned into a JSON object) which tells Matplotlib the color and size of the scatterplot markers (each signifying an agent). The only thing we need to provide is a function which takes an agent, and returns a portrayal dictionary. Here's the simplest one: it'll draw each agent as a blue, filled circle, with a radius size of 50." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Part 1 - Basic Dashboard\n", + "\n", + "**Note:** Due to the computational cost of running multiple dashboards it is recommended that at the end of each part you restart your kernel and then only run the the cells in that portion of the tutorial (e.g. Part 1). Each portion is entirely self contained." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import mesa\n", + "print(f\"Mesa version: {mesa.__version__}\")\n", + "\n", + "from mesa.visualization import SolaraViz, make_plot_measure, make_space_matplotlib\n", + "# Import the local MoneyModel.py\n", + "from MoneyModel import MoneyModel\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -121,10 +138,8 @@ }, "outputs": [], "source": [ - "from mesa.visualization import SolaraViz, make_plot_measure, make_space_matplotlib\n", - "\n", "# Create initial model instance\n", - "model1 = BoltzmannWealthModel(50, 10, 10)\n", + "model1 = MoneyModel(50, 10, 10)\n", "\n", "SpaceGraph = make_space_matplotlib(agent_portrayal)\n", "GiniPlot = make_plot_measure(\"Gini\")\n", @@ -143,7 +158,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Changing the agents\n", + "## Part 2 - Dynamic Agent Representation \n", + "\n", + "Due to the computational cost of running multiple dashboards it is recommended that at the end of each part you restart your kernel and then only run the import cell and the cells in that portion of the part of the tutorial (e.g. Part 2)\n", + "\n", "\n", "In the visualization above, all we could see is the agents moving around -- but not how much money they had, or anything else of interest. Let's change it so that agents who are broke (wealth 0) are drawn in red, smaller. (TODO: Currently, we can't predict the drawing order of the circles, so a broke agent may be overshadowed by a wealthy agent. We should fix this by doing a hollow circle instead)\n", "In addition to size and color, an agent's shape can also be customized when using the default drawer. The allowed values for shapes can be found [here](https://matplotlib.org/stable/api/markers_api.html).\n", @@ -151,6 +169,20 @@ "To do this, we go back to our `agent_portrayal` code and add some code to change the portrayal based on the agent properties and launch the server again." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import mesa\n", + "print(f\"Mesa version: {mesa.__version__}\")\n", + "\n", + "from mesa.visualization import SolaraViz, make_plot_measure, make_space_matplotlib\n", + "# Import the local MoneyModel.py\n", + "from MoneyModel import MoneyModel\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -163,7 +195,20 @@ " if agent.wealth > 0:\n", " size = 50\n", " color = \"tab:blue\"\n", - " return {\"size\": size, \"color\": color}" + " return {\"size\": size, \"color\": color}\n", + "\n", + "model_params = {\n", + " \"n\": {\n", + " \"type\": \"SliderInt\",\n", + " \"value\": 50,\n", + " \"label\": \"Number of agents:\",\n", + " \"min\": 10,\n", + " \"max\": 100,\n", + " \"step\": 1,\n", + " },\n", + " \"width\": 10,\n", + " \"height\": 10,\n", + "}" ] }, { @@ -172,6 +217,12 @@ "metadata": {}, "outputs": [], "source": [ + "# Create initial model instance\n", + "model1 = MoneyModel(50, 10, 10)\n", + "\n", + "SpaceGraph = make_space_matplotlib(agent_portrayal)\n", + "GiniPlot = make_plot_measure(\"Gini\")\n", + "\n", "page = SolaraViz(\n", " model1,\n", " components=[SpaceGraph, GiniPlot],\n", @@ -186,7 +237,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Building your own visualization component\n", + "## Part 3 - Custom Components \n", + "\n", + "Due to the computational cost of running multiple dashboards it is recommended that at the end of each part you restart your kernel and then only run the import cell and the cells in that portion of the part of the tutorial (e.g. Part 3)\n", "\n", "**Note:** This section is for users who have a basic familiarity with Python's Matplotlib plotting library.\n", "\n", @@ -197,6 +250,63 @@ "**Note:** Due to the way solara works we need to trigger an update whenever the underlying model changes. For this you need to register an update counter with every component." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import mesa\n", + "print(f\"Mesa version: {mesa.__version__}\")\n", + "\n", + "from mesa.visualization import SolaraViz, make_plot_measure, make_space_matplotlib\n", + "# Import the local MoneyModel.py\n", + "from MoneyModel import MoneyModel\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def agent_portrayal(agent):\n", + " size = 10\n", + " color = \"tab:red\"\n", + " if agent.wealth > 0:\n", + " size = 50\n", + " color = \"tab:blue\"\n", + " return {\"size\": size, \"color\": color}\n", + "\n", + "model_params = {\n", + " \"n\": {\n", + " \"type\": \"SliderInt\",\n", + " \"value\": 50,\n", + " \"label\": \"Number of agents:\",\n", + " \"min\": 10,\n", + " \"max\": 100,\n", + " \"step\": 1,\n", + " },\n", + " \"width\": 10,\n", + " \"height\": 10,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from mesa.visualization import SolaraViz, make_plot_measure, make_space_matplotlib\n", + "\n", + "# Create initial model instance\n", + "model1 = MoneyModel(50, 10, 10)\n", + "\n", + "SpaceGraph = make_space_matplotlib(agent_portrayal)\n", + "GiniPlot = make_plot_measure(\"Gini\")" + ] + }, { "cell_type": "code", "execution_count": null, @@ -221,20 +331,32 @@ " solara.FigureMatplotlib(fig)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In a notebook environment we can directly display the visualization by calling it with the model instance" - ] - }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "Histogram(model1)" + "def agent_portrayal(agent):\n", + " size = 10\n", + " color = \"tab:red\"\n", + " if agent.wealth > 0:\n", + " size = 50\n", + " color = \"tab:blue\"\n", + " return {\"size\": size, \"color\": color}\n", + "\n", + "model_params = {\n", + " \"n\": {\n", + " \"type\": \"SliderInt\",\n", + " \"value\": 50,\n", + " \"label\": \"Number of agents:\",\n", + " \"min\": 10,\n", + " \"max\": 100,\n", + " \"step\": 1,\n", + " },\n", + " \"width\": 10,\n", + " \"height\": 10,\n", + "}" ] }, { @@ -260,6 +382,22 @@ "page" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can even run the visuals independently by calling it with the model instance" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Histogram(model1)" + ] + }, { "cell_type": "markdown", "metadata": {}, From 085e98ccf3cd05bc279beb78f6112c23971da6f5 Mon Sep 17 00:00:00 2001 From: Tom Pike Date: Sun, 20 Oct 2024 15:40:05 -0400 Subject: [PATCH 6/6] Update intro_tutorial.ipynb - update agent "do" section - remove schedule reference in batch_run - other minor fixes --- docs/tutorials/intro_tutorial.ipynb | 75 ++++++++++++++--------------- 1 file changed, 36 insertions(+), 39 deletions(-) diff --git a/docs/tutorials/intro_tutorial.ipynb b/docs/tutorials/intro_tutorial.ipynb index 3fb6f340298..874fe71bbfa 100644 --- a/docs/tutorials/intro_tutorial.ipynb +++ b/docs/tutorials/intro_tutorial.ipynb @@ -279,7 +279,7 @@ " # Create the agent's attribute and set the initial values.\n", " self.wealth = 1\n", "\n", - " def step(self):\n", + " def say_hi(self):\n", " # The agent's step will go here.\n", " # For demonstration purposes we will print the agent's unique_id\n", " print(f\"Hi, I am an agent, you can call me {str(self.unique_id)}.\")\n", @@ -299,9 +299,9 @@ " def step(self):\n", " \"\"\"Advance the model by one step.\"\"\"\n", "\n", - " # This function psuedo-randomly reorders the list of agent objects and then iterates through calling the function passed in as the parameter\n", - " # In this case we use the ABM convention step but it could be any function in the Agent class\n", - " self.agents.shuffle_do(\"step\")" + " # This function psuedo-randomly reorders the list of agent objects and \n", + " # then iterates through calling the function passed in as the parameter\n", + " self.agents.shuffle_do(\"say_hi\")" ] }, { @@ -396,7 +396,7 @@ " # Create the agent's variable and set the initial values.\n", " self.wealth = 1\n", "\n", - " def step(self):\n", + " def say_wealth(self):\n", " # The agent's step will go here.\n", " # FIXME: need to print the agent's wealth\n", " print(f\"Hi, I am an agent and I am broke!\")" @@ -423,28 +423,19 @@ "# Fixme: Create the model object, and run it" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Challenge: Change the agent step function to some else like \"talk\" function and call it from `shuffle_do`" - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Agent Step\n", + "### Agents Exchange\n", "\n", - "Returning back to the MoneyAgent the actual step process is now going to be created.\n", + "Returning back to the MoneyAgent the actual exchange process is now going to be created.\n", "\n", "**Background:** This is where the agent's behavior as it relates to each step or tick of the model is defined.\n", "\n", "**Model-specific information:** In this case, the agent will check its wealth, and if it has money, give one unit of it away to another random agent.\n", "\n", - "**Code implementation:** The agent's step method is called by `mesa.Agent.shuffle_do(\"step\")`during each step of the model. To allow the agent to choose another agent at random, we use the `model.random` random-number generator. This works just like Python's `random` module, but if a fixed seed set is set when the model is instantiated (see earlier challenge), this allows users to replicate a specific model run later. Once we identify this other agent object we increase their wealth by 1 and decrease this agents wealth by one.\n", + "**Code implementation:** The agent's step method is called by `mesa.Agent.shuffle_do(\"exchange\")`during each step of the model. To allow the agent to choose another agent at random, we use the `model.random` random-number generator. This works just like Python's `random` module, but if a fixed seed set is set when the model is instantiated (see earlier challenge), this allows users to replicate a specific model run later. Once we identify this other agent object we increase their wealth by 1 and decrease this agents wealth by one.\n", "\n", "This updates the step function as shown below" ] @@ -465,13 +456,31 @@ " # Create the agent's variable and set the initial values.\n", " self.wealth = 1\n", "\n", - " def step(self):\n", + " def exchange(self):\n", " # Verify agent has some wealth\n", " if self.wealth > 0:\n", " other_agent = self.random.choice(self.model.agents)\n", " if other_agent is not None:\n", " other_agent.wealth += 1\n", - " self.wealth -= 1" + " self.wealth -= 1\n", + "\n", + "class MoneyModel(mesa.Model):\n", + " \"\"\"A model with some number of agents.\"\"\"\n", + "\n", + " def __init__(self, n):\n", + " super().__init__()\n", + " self.num_agents = n\n", + " \n", + " # Create agents\n", + " for _ in range(self.num_agents):\n", + " a = MoneyAgent(self) # This calls the agent class parameter n number of times \n", + "\n", + " def step(self):\n", + " \"\"\"Advance the model by one step.\"\"\"\n", + "\n", + " # This function psuedo-randomly reorders the list of agent objects and \n", + " # then iterates through calling the function passed in as the parameter\n", + " self.agents.shuffle_do(\"exchange\")" ] }, { @@ -488,7 +497,7 @@ "from money_model import MoneyModel\n", "```\n", "\n", - "now let's create a model with 10 agents, and run it for 10 steps." + "now let's create a model with 10 agents, and run it for 30 steps." ] }, { @@ -498,7 +507,7 @@ "outputs": [], "source": [ "model = MoneyModel(10) # Tels the model to create 10 agents\n", - "for _ in range(10): #Runs the model for 10 steps; an underscore is common convention for a variable that is not used\n", + "for _ in range(30): #Runs the model for 10 steps; an underscore is common convention for a variable that is not used\n", " model.step()" ] }, @@ -523,13 +532,6 @@ "); # The semicolon is just to avoid printing the object representation" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You'll should see something like the distribution above. Yours will almost certainly look at least slightly different, since each run of the model is random, after all." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -548,7 +550,7 @@ "for _ in range(100):\n", " # Run the model\n", " model = MoneyModel(10)\n", - " for _ in range(10):\n", + " for _ in range(30):\n", " model.step()\n", "\n", " # Store the results\n", @@ -1419,7 +1421,8 @@ "\n", " def step(self):\n", " self.datacollector.collect(self)\n", - " self.agents.shuffle_do(\"step\")\n", + " self.agents.shuffle_do(\"move\")\n", + " self.agents.shuffle_do(\"give_money\")\n", "\n", "\n", "class MoneyAgent(mesa.Agent):\n", @@ -1445,13 +1448,6 @@ " self.wealth -= 1\n", " self.steps_not_given = 0\n", " else:\n", - " self.steps_not_given += 1\n", - "\n", - " def step(self):\n", - " self.move()\n", - " if self.wealth > 0:\n", - " self.give_money()\n", - " else:\n", " self.steps_not_given += 1" ] }, @@ -1475,7 +1471,7 @@ "* `data_collection_period`\n", " The length of the period (number of steps) after which the model and agent reporters collect data. Optional. If not specified, defaults to -1, i.e. only at the end of each episode.\n", "* `max_steps`\n", - " The maximum number of time steps after which the model halts. An episode does either end when `self.running` of the model class is set to `False` or when `model.schedule.steps == max_steps` is reached. Optional. If not specified, defaults to 1000.\n", + " The maximum number of time steps after which the model halts. An episode does either end when `self.running` of the model class is set to `False` or when `model.steps == max_steps` is reached. Optional. If not specified, defaults to 1000.\n", "* `display_progress`\n", " Display the batch run progress. Optional. If not specified, defaults to `True`." ] @@ -1757,7 +1753,8 @@ "metadata": {}, "outputs": [], "source": [ - "# Challenge: Treat the seed as a parameter and see the impact on the Gini Coefficient. You can also plot the seeds against the Gini Coefficient by changing the \"hue\" parameter in sns.lineplot function. " + "# Challenge: Treat the seed as a parameter and see the impact on the Gini Coefficient. \n", + "# You can also plot the seeds against the Gini Coefficient by changing the \"hue\" parameter in sns.lineplot function. " ] }, {