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": "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", + "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": "iVBORw0KGgoAAAANSUhEUgAAArwAAAGHCAYAAABS74GwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABWbElEQVR4nO3dd1hUV/4/8PelDkEYrICCWFGxIIJKsWws2INu7MZY17UlKpqNxORr2yxqjC1RjJsoawli7Els2AvGWEBdNWqiK4ggEaUkURA4vz/8cePIADM4M3cc3q/nmSfOueee87nHO+MnZ869VxJCCBARERERWSgrpQMgIiIiIjImJrxEREREZNGY8BIRERGRRWPCS0REREQWjQkvEREREVk0JrxEREREZNGY8BIRERGRRWPCS0REREQWjQkvEREREVk0JrxEZubSpUsYM2YM6tevDwcHBzg4OKBhw4b4+9//jnPnzmnUnTNnDiRJKlc/R48ehSRJOHr0qAGiNry8vDyMHz8e7u7usLa2RsuWLQEADx8+xODBg1GjRg1IkoS+ffsCACRJwpw5c/Tq43//+x8kSUJ0dLRBY3/R119/jWXLlhm1D0tUdH4/ePBA6VB0cujQIQQEBMDR0RGSJGHnzp1Kh/RSeN6SJbFROgAi+tMXX3yByZMno1GjRpgyZQqaNm0KSZJw7do1xMTEoHXr1vj5559Rv359AMDYsWPRvXv3cvXVqlUrnD59Gj4+PoY8BIOJiorCF198gc8++wz+/v6oVKkSAGD+/PnYsWMH1q5di/r166NKlSoAgNOnT8PDw0OvPtzd3XH69Gl5PI3l66+/xn//+19MnTrVqP2QcoQQGDhwILy9vbF79244OjqiUaNGSof1UnjekiVhwktkJk6dOoWJEyeiV69e2Lp1K+zs7ORtnTp1wqRJk/DNN9/AwcFBLvfw8NA7ySvi7OyMwMDAl47bWP773//CwcEBkydPLlZev359DBs2TKO8PMdib29v1mNApvHHH3/gtddee6k27t27h4cPH6Jfv37o3LmzgSIjIoMRRGQWevbsKWxtbcW9e/d03mf27NnixY+xl5eX6NWrl9i7d6/w8/MTKpVKNGrUSHz11Vca9Y4cOSIAiCNHjpTZz927d8Xf/vY34eHhIWxtbYW7u7t48803RVpamlznzp07YtiwYaJ69erCzs5ONG7cWCxevFgUFBRotJWbmyvmz58vGjVqJOzs7ES1atXEyJEjRXp6ulwHQLHXunXrtJYXxQ9AzJ49W6+4b9++Lbf9vBs3boghQ4ZoHMvnn3+udfy+/vpr8cEHHwh3d3fh5OQkOnfuLH766Se5XseOHbXGXZKwsDBRu3btYuMmhBBt2rQRfn5+8vstW7aINm3aCGdnZ+Hg4CDq1q0rRo0aVWLbpenYsaNo2rSp+PHHH0W7du3k9iIjIzViKfp7uH37ttbxeP58KmozPj5eBAUFCZVKJby8vMTatWuFEEJ89913ws/PTzg4OIhmzZqJvXv3arRZdH5fuHBB9OvXTzg5OQlnZ2cxbNgwjfOlyObNm0VgYKB47bXXhKOjowgNDRUXLlzQqDNixAjh6OgoLl26JLp27SoqVaokAgMDSx2bEydOiE6dOolKlSoJBwcHERQUJL777rticT7/8vLyKrG9x48fi/DwcOHr6yucnZ1F5cqVRWBgoNi5c2exuo8ePRKjR48WlStXFo6OjqJnz57il19+0Xq+m/K8XbVqlWjRooVwdHQUlSpVEo0aNRIRERGljiORkpjwEpmB/Px8+R9SfZSU8Hp4eAgfHx+xfv16sX//fjFgwAABQBw7dkyup2vCe/fuXeHu7i6qVasmlixZIg4ePChiY2PF6NGjxbVr14QQQqSnp4tatWqJ6tWri9WrV4t9+/aJyZMnCwBiwoQJclsFBQWie/fuwtHRUcydO1fExcWJL7/8UtSqVUv4+PiIP/74QwghxOnTp0XPnj2Fg4ODOH36tDh9+rRIS0sTp0+fFn5+fqJevXpyeVZWlhCieMKrS9zaEt4rV64ItVotmjdvLtavXy8OHDggpk+fLqysrMScOXOKjV+dOnXEsGHDxPfffy9iYmJE7dq1RcOGDUV+fr7cXkhIiHBzc5NjPn36dInjvWvXLgFAxMXFaZRfu3ZNABArVqwQQggRHx8vJEkSgwcPFnv27BGHDx8W69atE8OHDy/177MkHTt2FFWrVhUNGzYUq1evFnFxcWLixIkCgPjPf/4j19M34a1atar8P1z79+8XvXv3FgDE3LlzRfPmzUVMTIzYs2ePCAwMFPb29iIlJUXev+j89vLyEu+9957Yv3+/WLJkiXB0dBR+fn4iLy9Prvvxxx8LSZLE6NGjxXfffSe2b98ugoKChKOjo7hy5Ypcb8SIEcLW1lbUqVNHREZGikOHDon9+/eXOC5Hjx4Vtra2wt/fX8TGxoqdO3eK0NBQIUmS2Lx5sxBCiOTkZLF9+3YBQLzzzjvi9OnTxRLt52VmZoqRI0eKDRs2iMOHD4t9+/aJGTNmCCsrK42xLigoEO3atRMqlUosWLBAHDhwQMydO1c0bNiw2PluyvM2JiZGPtYDBw6IgwcPitWrV4t33323xGMmUhoTXiIzkJaWJgCIwYMHF9uWn58vnj59Kr8KCwvlbSUlvCqVSty5c0cue/z4sahSpYr4+9//LpfpmvCOHj1a2NraiqtXr5ZYZ+bMmQKAOHPmjEb5hAkThCRJ4vr160KIP/+h3LZtm0a9s2fPCgBi1apVclnRTNyLimYNX/RiAqBL3NoS3m7dugkPDw85kS4yefJkoVKpxMOHD4UQf45fz549Nept2bJFANBIanv16lXqjN/znj59KlxdXcXQoUM1yv/xj38IOzs78eDBAyGEEIsXLxYARGZmpk7tlqVoRu/Fv0MfHx/RrVs3+b2+CS8Ace7cObksIyNDWFtbCwcHB43kNjExUSOhF+LP83vatGkafW3atEkAEBs3bhRCCJGUlCRsbGzEO++8o1EvJydHuLm5iYEDB8plI0aMEADkWeayBAYGiho1aoicnBy5LD8/XzRr1kx4eHjIn8eic+mTTz7Rqd3nFX3Gx4wZozGD//333wsAIioqSqN+ZGRksfPdlOft5MmThYuLi97HSaQk3qWByMz5+/vD1tZWfn366adl7tOyZUvUrl1bfq9SqeDt7Y07d+7o3f/evXvx+uuvo0mTJiXWOXz4MHx8fNCmTRuN8pEjR0IIgcOHDwMAvvvuO7i4uKBPnz7Iz8+XXy1btoSbm5tB7xihS9wvevLkCQ4dOoR+/frhtdde04ixZ8+eePLkCX744QeNfd544w2N9y1atACAco01ANjY2OCtt97C9u3bkZWVBQAoKCjAhg0bEBYWhqpVqwIAWrduDQAYOHAgtmzZgpSUlHL19zw3N7dif4ctWrQo97EAzy4M9Pf3l99XqVIFNWrUQMuWLVGzZk25vOjvSVtfL67XHjhwIGxsbHDkyBEAwP79+5Gfn4+3335b4+9MpVKhY8eOWs+rN998s8zYf//9d5w5cwb9+/eXL5oEAGtrawwfPhx3797F9evXy2xHm2+++QYhISGoVKkSbGxsYGtri6+++grXrl2T6xw7dkw+3ucNGTJE472pz9s2bdogMzMTQ4YMwa5du16Zu2hQxcaEl8gMVKtWDQ4ODlr/sfn6669x9uxZ7N69W+f2ipKi59nb2+Px48d6x/brr7+WeWFcRkYG3N3di5UXJTQZGRkAgPv37yMzMxN2dnYaSbytrS3S0tIM+g+nLnG/KCMjA/n5+fjss8+KxdezZ08AKBbji2Ntb28PAOUa6yKjR4/GkydPsHnzZgDPErrU1FSMGjVKrtOhQwfs3LlTTvQ8PDzQrFkzxMTElLtfQ543RYruovE8Ozu7YuVFF2k+efKkWH03NzeN9zY2NqhatarGeQU8+5+AF//eYmNji/2dvfbaa3B2di4z9kePHkEIodO5rY/t27dj4MCBqFWrFjZu3IjTp0/j7Nmz8t97kYyMDNjY2BQbK1dXV433pj5vhw8fjrVr1+LOnTt48803UaNGDbRt2xZxcXG6DwKRifEuDURmwNraGp06dcKBAweQmpqq8Q9s0W3D/ve//ykSW/Xq1XH37t1S61StWhWpqanFyu/duwfgWUJf9N+qVati3759WttxcnJ6yWj/pEvcL6pcubI8ezdp0iStderWrWuI8EpVNFu+bt06/P3vf8e6detQs2ZNhIaGatQLCwtDWFgYcnNz8cMPPyAyMhJDhw5FnTp1EBQUZJTYVCoVACA3N1ej3JizfGlpaahVq5b8Pj8/HxkZGXLSVnR+bd26FV5eXmW2p+u9qytXrgwrKyudzm19bNy4EXXr1kVsbKxGLC+OadWqVZGfn4+HDx9qJL1paWnF4jT1eTtq1CiMGjUKv//+O44fP47Zs2ejd+/euHHjhk5/B0SmxoSXyExERERg7969GD9+PLZu3QpbW1ulQwIA9OjRAxs2bMD169dLvK9o586dERkZiQsXLqBVq1Zy+fr16yFJEl5//XUAQO/evbF582YUFBSgbdu2isf9otdeew2vv/46EhIS0KJFC41bw72M8sySjho1ChMmTMDJkyfx7bffIjw8HNbW1iW237FjR7i4uGD//v1ISEgwWsJbp04dAM8ekPL8uOrzC4S+Nm3apLEsYsuWLcjPz8df/vIXAEC3bt1gY2ODX375RaelCrpydHRE27ZtsX37dixevFi+JWBhYSE2btwIDw8PeHt7692uJEmws7PTSHbT0tKwa9cujXodO3bEokWLEBsbiwkTJsjlRTP/RZQ8bx0dHdGjRw/k5eWhb9++uHLlChNeMktMeInMREhICFauXIl33nkHrVq1wrhx49C0aVN5hmnbtm0AoNNPsYY0b9487N27Fx06dMAHH3yA5s2bIzMzE/v27UN4eDgaN26MadOmYf369ejVqxfmzZsHLy8vfP/991i1ahUmTJggJwWDBw/Gpk2b0LNnT0yZMgVt2rSBra0t7t69iyNHjiAsLAz9+vUzWdzaLF++HO3atUP79u0xYcIE1KlTBzk5Ofj555/x7bffyuuR9dG8eXNs374dUVFR8Pf3h5WVFQICAkrdZ8iQIQgPD8eQIUOQm5uLkSNHamz/v//7P9y9exedO3eGh4cHMjMzsXz5ctja2qJjx45yPRsbG3Ts2BGHDh3SO25tWrdujUaNGmHGjBnIz89H5cqVsWPHDpw8edIg7Wuzfft22NjYoGvXrrhy5Qo++ugj+Pr6ymtb69Spg3nz5mHWrFm4desWunfvjsqVK+P+/fv48ccf4ejoiLlz55ar78jISHTt2hWvv/46ZsyYATs7O6xatQr//e9/ERMTU64nHfbu3Rvbt2/HxIkT0b9/fyQnJ2P+/Plwd3fHzZs35Xrdu3dHSEgIpk+fjuzsbPj7++P06dNYv349AMDK6s9ViaY8b//2t7/BwcEBISEhcHd3R1paGiIjI6FWq+W15UTmhgkvkRkZP348goKCsHz5cixduhT37t2DJEnw8PBAcHAwDh06hE6dOpk0plq1auHHH3/E7NmzsWDBAmRkZKB69epo166d/DNr9erVER8fj4iICERERCA7Oxv16tXDokWLEB4eLrdlbW2N3bt3Y/ny5diwYQMiIyNhY2MDDw8PdOzYEc2bNzdp3Nr4+PjgwoULmD9/Pj788EOkp6fDxcUFDRs2lNdD6mvKlCm4cuUKPvjgA2RlZUE8u0NOqfuo1Wr069cPX3/9NUJCQorNJLZt2xbnzp3D+++/j19//RUuLi4ICAjA4cOH0bRpU7leQUEBCgoKyhW3NtbW1vj2228xefJkjB8/Hvb29hg8eDA+//xz9OrVy2D9PG/79u2YM2cOoqKiIEkS+vTpg2XLlmnMZEZERMDHxwfLly9HTEwMcnNz4ebmhtatW2P8+PHl7rtjx444fPgwZs+ejZEjR6KwsBC+vr7YvXs3evfuXa42R40ahfT0dKxevRpr165FvXr1MHPmTNy9e1cjMbeyssK3336L6dOnY8GCBcjLy0NISAg2btyIwMBAuLi4yHVNed62b98e0dHR2LJlCx49eoRq1aqhXbt2WL9+PapXr16uvoiMTRJlfesSERGR2fj6668xbNgwnDp1CsHBwUqHQ/RKYMJLRERkpmJiYpCSkoLmzZvDysoKP/zwAz755BP4+fnJty0jorJxSQMREZGZcnJywubNm/HPf/4Tv//+O9zd3TFy5Ej885//VDo0olcKZ3iJiIiIyKLxwRNEREREZNGY8BIRERGRRWPCS0REREQWjRetaVFYWIh79+7BycmpXDcVJyIiIiLjEkIgJycHNWvW1HgQizZMeLW4d+8ePD09lQ6DiIiIiMqQnJwMDw+PUusw4dXCyckJwLMBNPVjXImIiIiobNnZ2fD09JTzttIw4dWiaBmDs7MzE14iIiIiM6bL8lNetEZEREREFo0JLxERERFZNCa8RERERGTRmPASERERkUVjwktEREREFo0JLxERERFZNCa8RERERGTRmPASERERkUVjwktEREREFo1PWiMiMrL+UfFIzXoCAHBXq7B1QrDCERERVSxMeImIjCw16wlSMh8rHQYRUYXFJQ1EREREZNE4w0tERsOf8omIyBww4SUio+FP+eaB/+NBRBUdE14iIgvH//EgooqOCS+RBePMHhERERNeIovGmT0iIiLepYGIiIiILJziCe+qVatQt25dqFQq+Pv748SJEyXWHTlyJCRJKvZq2rSpRr1t27bBx8cH9vb28PHxwY4dO4x9GERERERkphRNeGNjYzF16lTMmjULCQkJaN++PXr06IGkpCSt9ZcvX47U1FT5lZycjCpVqmDAgAFyndOnT2PQoEEYPnw4Ll68iOHDh2PgwIE4c+aMqQ6LiIiIiMyIognvkiVLMGbMGIwdOxZNmjTBsmXL4OnpiaioKK311Wo13Nzc5Ne5c+fw6NEjjBo1Sq6zbNkydO3aFREREWjcuDEiIiLQuXNnLFu2zERHRURERETmRLGL1vLy8nD+/HnMnDlTozw0NBTx8fE6tfHVV1+hS5cu8PLykstOnz6NadOmadTr1q1bqQlvbm4ucnNz5ffZ2dk69U9UGt4hgYiIyDwoNsP74MEDFBQUwNXVVaPc1dUVaWlpZe6fmpqKvXv3YuzYsRrlaWlpercZGRkJtVotvzw9PfU4EiLtiu6QkJL5WE58iYiIyPQUv2hNkiSN90KIYmXaREdHw8XFBX379n3pNiMiIpCVlSW/kpOTdQueiIiIiMyeYksaqlWrBmtr62Izr+np6cVmaF8khMDatWsxfPhw2NnZaWxzc3PTu017e3vY29vreQRERERE9CpQbIbXzs4O/v7+iIuL0yiPi4tDcHDpax2PHTuGn3/+GWPGjCm2LSgoqFibBw4cKLNNIiIiIrJMij5pLTw8HMOHD0dAQACCgoKwZs0aJCUlYfz48QCeLTVISUnB+vXrNfb76quv0LZtWzRr1qxYm1OmTEGHDh2wcOFChIWFYdeuXTh48CBOnjxpkmMiIqLieBEnESlJ0YR30KBByMjIwLx585CamopmzZphz5498l0XUlNTi92TNysrC9u2bcPy5cu1thkcHIzNmzfjww8/xEcffYT69esjNjYWbdu2NfrxEBGRdnzMNREpSdGEFwAmTpyIiRMnat0WHR1drEytVuOPP/4otc3+/fujf//+hgiPiIiIiF5xit+lgYjIkgkhkFdQKL/PfvwUF5IeQQihYFRERBWL4jO8ZJm4Xo8IuHE/BzO+uYhfc/58sE1Obj7+uioeLTzUWDzAF96uTgpGSKbE70Ui5TDhJaPgej2q6G7cz0H/qHhkP8nXuv3S3Sz0j4rH1gnBTHpNROmEk9+LRMrhkgYiIgMTQmDGNxdLTHaLZD/Jx3vfXOTyBhPh0w+JKi4mvEREBpaQnIlLd7N0qnvxbhYSkzONGxARUQXHhJeIyMDirt7Xq/4BPesTEZF+mPASERlY1uOnRq1PRET6YcJLRGRgagdbo9YnIiL9MOElIjKwrj6uetUP1bM+ERHphwkvEZGB+Xm6oIWHWqe6vh5qtPR0MW5AREQVHBNeIiIDkyQJiwf4wllV+q3OnVU2+GSALyRJMlFkREQVExNeIiIj8HZ1wtYJwSXO9Pp6qPnQCSIiE2HCS0RkJN6uTtg1KQTVnezlMid7G+yYGIydk0KY7FYgQgjkFRTK77MfP8WFpEd86AiRiTDhJSIyIkmSYGf951ets4Mt/GpX5jKGCuTG/RyErTyFX3Ny5bKc3Hz8dVU8wlaewo37OQpGR1QxMOElIiIykhv3c9A/Kr7EJ+9dupuF/lHxTHqJjIwJLxERkREIITDjm4vIfpJfar3sJ/l475uLXN5AZESlX0JM9IrqHxWP1KwnAAB3tQpbJwQrHBGRMkpaO+rn6cJlFUaWkJxZ4szuiy7ezUJicib8alc2clTK4nczKYUJL1mk1KwnSMl8rHQYZAYq8j+wN+7nYMY3F7WuHW3hocbiAb68cM6I4q7e16v+gav3LT7h5XczKYVLGojIKMzlqvSif2BTMh/LiW9FwLWjyst6/NSo9YlId5zhJSKD48yisvRdO7pzUgiXNxiB2sHWqPWpfCryrz7mxNR/D0x4icigimYWS0q2imYW+dAF4+HaUfPQ1ccVUUd/0bl+qI+rEaOhIlxWYR5Jv6n/HrikgYgMhlelm4fyrB0lw/PzdCnxSXsv8vVQo6Wni3EDIvr/KuJSLya8RGQw5ZlZJMPj2lHzIEkSFg/whbOq9B9TnVU2+GSAL5eVEBkRE14iC6XERWOcWTQPXDtqPrxdnbB1QnCJM72+Hmou7yEyASa8REag9B0KlHqUKWcWzUNXPdeCGnvtqNKfB6V5uzph16QQVHeyl8uc7G2wY2Iwdk4KYbJLZAJMeIkMTKlk8/n+lbodFWcWzYM5rR1V+vNgLiRJgp31n//kOjvYwq92ZS5jIDIRJrxEBqT0vU+VvmjM3GYWKypzWTuq9OeBiKgIE14iA1E62QSUv2jMnGYWKzql146aw+eBiKgIE14iA1E62QSUv2jMXGYW6Rkl146aw+fheRV9HTFRRceEl8hAlE42AfO4aEzpmUXSpNTaUXP4PBThOmIi4pPWiAzEHJJNc7lorGhmsc2/DslJhpO9DdaPaYOWni6c2a0AzOHzAPDJf6SppJl+PxN/L5nDk84qGs7wEhmIOSSb5nTRGK9Kr9jM4fPAdcT0PHOa6VfySWcVdXmP4gnvqlWrULduXahUKvj7++PEiROl1s/NzcWsWbPg5eUFe3t71K9fH2vXrpW3R0dHQ5KkYq8nTyrGo/NIOeaQbPKiMTIX5vB5MLd1xKQc3jHkGXNK+k1N0YQ3NjYWU6dOxaxZs5CQkID27dujR48eSEpKKnGfgQMH4tChQ/jqq69w/fp1xMTEoHHjxhp1nJ2dkZqaqvFSqVTGPhyq4Mwh2eRFY2QuzOHzYE7riM1F/6h4hCw4jJAFh9E/Kl7pcEyCM/3PVPSkX9GEd8mSJRgzZgzGjh2LJk2aYNmyZfD09ERUVJTW+vv27cOxY8ewZ88edOnSBXXq1EGbNm0QHKy59kWSJLi5uWm8iIzNXJJNXjRG5sAcPg/mso64iLtahVouDqjl4gB3tTKTMEr+lK4UzvSbX9KvxLIKxRLevLw8nD9/HqGhoRrloaGhiI/X/n+du3fvRkBAABYtWoRatWrB29sbM2bMwOPHjzXq/fbbb/Dy8oKHhwd69+6NhISEUmPJzc1Fdna2xouoPMwl2eSjTM2LOSQ6SlD682AO64ift3VCME7N7IRTMzvxIiUT4ky/eSX9Si2rUOwuDQ8ePEBBQQFcXTXXbbm6uiItLU3rPrdu3cLJkyehUqmwY8cOPHjwABMnTsTDhw/ldbyNGzdGdHQ0mjdvjuzsbCxfvhwhISG4ePEiGjZsqLXdyMhIzJ0717AHSBWWudyhoKSLxsj0KnJyo+TnoauPK6KO/qJzfT75zzKZ20y/EneKKE/Sb4x/L5S8a4riF629+JcrhCjxL7ywsBCSJGHTpk1o06YNevbsiSVLliA6Olqe5Q0MDMRbb70FX19ftG/fHlu2bIG3tzc+++yzEmOIiIhAVlaW/EpOTjbcAVKFxDsUEP1Jqc+DOawjJuWZ00y/UrOb5pD0K72sQrGEt1q1arC2ti42m5uenl5s1reIu7s7atWqBbX6zy+wJk2aQAiBu3fvat3HysoKrVu3xs2bN0uMxd7eHs7OzhovIiJ6tZnDOmJSnjncMQRQ9qIxc0j6lV5WoVjCa2dnB39/f8TFxWmUx8XFFbsIrUhISAju3buH3377TS67ceMGrKys4OHhoXUfIQQSExPh7u5uuOCJ6JVQUe83SX9Seh0xKc8cZvqVnt00h6Rf6bXUii5pCA8Px5dffom1a9fi2rVrmDZtGpKSkjB+/HgAz5YavP3223L9oUOHomrVqhg1ahSuXr2K48eP47333sPo0aPh4OAAAJg7dy7279+PW7duITExEWPGjEFiYqLcZkVQEW87Q/Siiny/SdLEizgrNnOY6Vd6dtMckn6ll1UomvAOGjQIy5Ytw7x589CyZUscP34ce/bsgZeXFwAgNTVV4568lSpVQlxcHDIzMxEQEIBhw4ahT58+WLFihVwnMzMT48aNQ5MmTRAaGoqUlBQcP34cbdq0MfnxKaUi3naG6HkV/X6TVBzX1StPyV9clJ7pV3p20xySfqWXVSh2l4YiEydOxMSJE7Vui46OLlbWuHHjYssgnrd06VIsXbrUUOER0StG358Od04KYdJDFYISdwcocuN+DmZ8c1HrLy4tPNRYPMDXZLdrVOKOIUrPbgJ/Jv0zvrmodTLA10ONT4z496D0XVMUv0sDEZEhKf3TIZE5UnKJjzn94qLUTL/Ss5tFlFzeo/SyCia8RGRRlP7pkMjcKJlwKn2xlrkwh4vGiiiV9Cu9rIIJLxFZFHP46ZDIXCidcPIXl2eUnt00F0qupWbCSwbHW0GRkszlp0Mic6B0wslfXJ5RenbTnCi1rIIJLxkUbwVFSjOnnw6JlKZ0wslfXP6k9J0izIkSyyqY8JLBmNOFCVRx8adDoj8pnXCa4y8u7moVark4oJaLA9zVKqP39zzeE1o5it+WjCwDbwVF5qLop8P+UfGlno8V4adDIqUTTqVvRaXN1gnan+ZqKiXNbpJxcYaXDELpdWJEz+NPh0TPKL3Eh7+4kLlgwksGofQ6MaIX8adDIuUTTl6sReaCCS8ZhNLrxIi04eNkqaIzh4STv7iYHyXXMSuFa3jJIJReJ0ZERNop/UjZohiUeqyvOXo+yVQi4VR6HbMSmPCSQZjjhQlERPSMOSScvFjrTxUx4VQalzSQQSi9ToyIiErHJT5UkTHhJYMwh3ViRERERNow4SWD4YUJREREZI6Y8JJB8VZQREREZG540RoZHC9MICJzpPSV8USkHCa8REQWjoneM7wynsh8mPp7iQkvEZGFY6JHRObG1N9LTHiJyGg4s0hkXviZpIqKCS8RGQ1nFonMCz+TVFHxLg1EREREZNE4w0sWRwiBvIJC+X3246e4kPQIfiZ+Xjt/OiQiIjIPTHjJoty4n4MZ31yUnxUPADm5+fjrqni08FBj8QBfk90LmD8dEhERmQcuaSCLceN+DvpHxePS3Syt2y/dzUL/qHjcuJ9j4siIiIhISUx4ySIIITDjm4vIfpJfar3sJ/l475uLEEKYKDIiAp4t66nl4oBaLg5c4kNEJsclDWQREpIzS5zZfdHFu1lITM7k09+ITIhLfIhISUx4ySLEXb2vV/0DV+9XiISXF84RkTnhdxIphQkvWYSsx0+NWv9VxVk1/gNLZE74nURK0Tvhtba2RmpqKmrUqKFRnpGRgRo1aqCgoMBgwRHpSu1ga9T69OriP7BERKT3RWslXeyTm5sLOzu7lw6IqDy6+rjqVT9Uz/pERET06tJ5hnfFihUAAEmS8OWXX6JSpUrytoKCAhw/fhyNGzc2fIREOvDzdEELD7VOF675eqjR0tPF+EERERGRWdB5hnfp0qVYunQphBBYvXq1/H7p0qVYvXo1/vjjD6xevVrvAFatWoW6detCpVLB398fJ06cKLV+bm4uZs2aBS8vL9jb26N+/fpYu3atRp1t27bBx8cH9vb28PHxwY4dO/SOi14tkiRh8QBfOKtK/384Z5UNPhnga9InrhEREZGydJ7hvX37NgDg9ddfx/bt21G58stf4R4bG4upU6di1apVCAkJwRdffIEePXrg6tWrqF27ttZ9Bg4ciPv37+Orr75CgwYNkJ6ejvz8P++9evr0aQwaNAjz589Hv379sGPHDgwcOBAnT55E27ZtXzpmMl/erk7YOiEYM765qHWm19dDjU9M+KQ1IiIiMg+SUPAO/G3btkWrVq0QFRUllzVp0gR9+/ZFZGRksfr79u3D4MGDcevWLVSpUkVrm4MGDUJ2djb27t0rl3Xv3h2VK1dGTEyMTnFlZ2dDrVYjKysLzs7Oeh6V8kIWHEZK5mMAQC0XB5ya2alCxSCEQJt/HZIfL+xkb4P1Y9qgpacLZ3aJiIgshD75mt53aSgoKEB0dDQOHTqE9PR0FBYWamw/fPiwTu3k5eXh/PnzmDlzpkZ5aGgo4uPjte6ze/duBAQEYNGiRdiwYQMcHR3xxhtvYP78+XBwcADwbIZ32rRpGvt169YNy5YtKzGW3Nxc5Obmyu+zs7N1OgYyT5Ikwc76z9U6zg62FeKeu0RERKSd3gnvlClTEB0djV69eqFZs2blnjF78OABCgoK4OqqebW8q6sr0tLStO5z69YtnDx5EiqVCjt27MCDBw8wceJEPHz4UF7Hm5aWplebABAZGYm5c+eW6ziIiIiIyLzpnfBu3rwZW7ZsQc+ePQ0SwIsJsxCixCS6sLAQkiRh06ZNUKvVAIAlS5agf//+WLlypTzLq0+bABAREYHw8HD5fXZ2Njw9Pct1PERERERkXvROeO3s7NCgQYOX7rhatWqwtrYuNvOanp5ebIa2iLu7O2rVqiUnu8CzNb9CCNy9excNGzaEm5ubXm0CgL29Pezt7V/iaIiIiIjIXOn94Inp06dj+fLlJT6AQld2dnbw9/dHXFycRnlcXByCg7U/GSkkJAT37t3Db7/9JpfduHEDVlZW8PDwAAAEBQUVa/PAgQMltklERERElk3vGd6TJ0/iyJEj2Lt3L5o2bQpbW81HtG7fvl3ntsLDwzF8+HAEBAQgKCgIa9asQVJSEsaPHw/g2VKDlJQUrF+/HgAwdOhQzJ8/H6NGjcLcuXPx4MEDvPfeexg9erS8nGHKlCno0KEDFi5ciLCwMOzatQsHDx7EyZMn9T1UIiIiIrIAeie8Li4u6Nevn0E6HzRoEDIyMjBv3jykpqaiWbNm2LNnD7y8vAAAqampSEpKkutXqlQJcXFxeOeddxAQEICqVati4MCB+Oc//ynXCQ4OxubNm/Hhhx/io48+Qv369REbG8t78BIRERFVUHonvOvWrTNoABMnTsTEiRO1bouOji5W1rhx42JLFl7Uv39/9O/f3xDhEREREdErTu81vACQn5+PgwcP4osvvkBOTg4AFFtbS0RERERkDvSe4b1z5w66d++OpKQk5ObmomvXrnBycsKiRYvw5MkTrF692hhxEhERERGVi94zvFOmTEFAQAAePXokXygGAP369cOhQ4cMGhwRERER0csq110aTp06BTs7O41yLy8vpKSkGCwwIiIiIiJD0HuGt7CwEAUFBcXK7969CycnJ4MEReUnhEBeQaH8PvvxU1xIevTS900mIiIielXpnfB27doVy5Ytk99LkoTffvsNs2fPNtjjhql8btzPQdjKU/g1J1cuy8nNx19XxSNs5SncuJ+jYHREREREytA74V26dCmOHTsGHx8fPHnyBEOHDkWdOnWQkpKChQsXGiNG0sGN+znoHxWPS3eztG6/dDcL/aPimfQSERFRhaP3Gt6aNWsiMTERMTExuHDhAgoLCzFmzBgMGzZM4yI2Mh0hBGZ8cxHZT/JLrZf9JB/vfXMROyeFQJIkE0VHREREpCy9E14AcHBwwOjRozF69GhDx0PlkJCcWeLM7osu3s1CYnIm/GpXNnJUREREROZBp4R39+7d6NGjB2xtbbF79+5S677xxhsGCYx0F3f1vl71D1y9z4SXiIiIKgydEt6+ffsiLS0NNWrUQN++fUusJ0mS1js4kHFlPX5q1PpERERErzKdEt7CwkKtfybzoHawNWp9IiIioleZ3ndpIPPT1cdVr/qhetYnIiIiepXpnfC+++67WLFiRbHyzz//HFOnTjVETKQnP08XtPBQ61TX10ONlp4uxg2IiIiIyIzonfBu27YNISEhxcqDg4OxdetWgwRF+pEkCYsH+MJZVfoKFWeVDT4Z4MtbkhEREVGFonfCm5GRAbW6+Gyis7MzHjx4YJCgSH/erk7YOiG4xJleXw81tk4IhrcrH/9MREREFYve9+Ft0KAB9u3bh8mTJ2uU7927F/Xq1TNYYK+y/lHxSM16AgBwV6uwdUKwSfr1dnXCrkkhaPOvQ/LjhZ3sbbB+TBu09HThzC4RERFVSHonvOHh4Zg8eTJ+/fVXdOrUCQBw6NAhfPrpp1i2bJmh43slpWY9QUrmY0X6liQJdtZ/Ttw7O9gqcs9dd7VK65+JiIiITE3vhHf06NHIzc3Fxx9/jPnz5wMA6tSpg6ioKLz99tsGD5BeTaaa1SYiIiIqS7keLTxhwgRMmDABv/76KxwcHFCpUiVDx0VEREREZBDlSniLVK9e3VBxEBEREREZhU4Jb6tWrXDo0CFUrlwZfn5+pV78dOHCBYMFR0RERET0snRKeMPCwmBvbw8A6Nu3rzHjISIiIiIyKJ0S3sqVK8PK6tmV/6NGjYKHh4f8noiIiIjInOmUtYaHhyM7OxsAULduXT5ggoiIiIheGTrN8NasWRPbtm1Dz549IYTA3bt38eTJE611a9eubdAAiYiIiIhehk4J74cffoh33nkHkydPhiRJaN26dbE6QghIkoSCggKDB0lEREREVF46Jbzjxo3DkCFDcOfOHbRo0QIHDx5E1apVjR0bEREREdFL0ynhXbFiBcaNG4dmzZph3bp1CAoKgoODg7FjIyIiIiJ6aXpftDZ69Gjk5OQYNSgiIiIiIkPhRWtEREREZNF40RoRERERWTSdljSMGzcODx48wMWLFyGEQFxcHC5cuKDxSkhIKNdjhVetWoW6detCpVLB398fJ06cKLHu0aNHIUlSsddPP/0k14mOjtZap6QZaSIiIiKybDrN8AKAk5OTfNFaSEiI/KjhlxEbG4upU6di1apVCAkJwRdffIEePXrg6tWrpS6NuH79OpydneX31atX19ju7OyM69eva5SpVKqXjpeIiIiIXj16Px94xIgRePz4Mb788ktERETg4cOHAIALFy4gJSVFr7aWLFmCMWPGYOzYsWjSpAmWLVsGT09PREVFlbpfjRo14ObmJr+sra01tkuSpLHdzc1Nv4MkIiIiIouhd8J76dIleHt7Y+HChVi8eDEyMzMBADt27EBERITO7eTl5eH8+fMIDQ3VKA8NDUV8fHyp+/r5+cHd3R2dO3fGkSNHim3/7bff4OXlBQ8PD/Tu3RsJCQmltpebm4vs7GyNFxERERFZBr0T3mnTpmHkyJG4efOmxjKBHj164Pjx4zq38+DBAxQUFMDV1VWj3NXVFWlpaVr3cXd3x5o1a7Bt2zZs374djRo1QufOnTX6bdy4MaKjo7F7927ExMRApVIhJCQEN2/eLDGWyMhIqNVq+eXp6anzcRARERGRedN5DW+Rc+fOYc2aNcXKa9WqVWKiWhpJkjTeF93tQZtGjRqhUaNG8vugoCAkJydj8eLF6NChAwAgMDAQgYGBcp2QkBC0atUKn332GVasWKG13YiICISHh8vvs7OzmfQSERERWQi9Z3hVKpXWn/yvX79e7OKx0lSrVg3W1tbFkuT09PRis76lCQwMLHX21srKCq1bty61jr29PZydnTVeRERERGQZ9E54w8LCMG/ePDx9+hTAsxnapKQkzJw5E2+++abO7djZ2cHf3x9xcXEa5XFxcQgODta5nYSEBLi7u5e4XQiBxMTEUusQERERkeXSe0nD4sWL0bNnT9SoUQOPHz9Gx44dkZaWhqCgIHz88cd6tRUeHo7hw4cjICAAQUFBWLNmDZKSkjB+/HgAz5YapKSkYP369QCAZcuWoU6dOmjatCny8vKwceNGbNu2Ddu2bZPbnDt3LgIDA9GwYUNkZ2djxYoVSExMxMqVK/U9VCIiIiKyAHonvM7Ozjh58iQOHz6MCxcuoLCwEK1atUKXLl307nzQoEHIyMjAvHnzkJqaimbNmmHPnj3w8vICAKSmpiIpKUmun5eXhxkzZiAlJQUODg5o2rQpvv/+e/Ts2VOuk5mZiXHjxiEtLQ1qtRp+fn44fvw42rRpo3d8RERERPTqk4QQQukgzE12djbUajWysrLKtZ43ZMFhpGQ+BgDUcnHAqZmdDB2iWfdvDjgGRERElk2ffE3vNbwAcOzYMfTp0wcNGjRAw4YN8cYbb5T6SGAiIiIiIqXonfBu3LgRXbp0wWuvvYZ3330XkydPhoODAzp37oyvv/7aGDESEREREZWb3mt4P/74YyxatAjTpk2Ty6ZMmYIlS5Zg/vz5GDp0qEEDJCIiIiJ6GXrP8N66dQt9+vQpVv7GG2/g9u3bBgmK6GW5q1Wo5eKAWi4OcFeryt6BiIiILJbeM7yenp44dOgQGjRooFF+6NAhPp2MzMbWCbrfy5mIiIgsm94J7/Tp0/Huu+8iMTERwcHBkCQJJ0+eRHR0NJYvX26MGImIiIiIyk3vhHfChAlwc3PDp59+ii1btgAAmjRpgtjYWISFhRk8QCIiIiKil6F3wgsA/fr1Q79+/QwdCxERERGRwel90drZs2dx5syZYuVnzpzBuXPnDBIUEREREZGh6J3wTpo0CcnJycXKU1JSMGnSJIMERURERERkKHonvFevXkWrVq2Klfv5+eHq1asGCYqIiIiIyFD0Tnjt7e1x//79YuWpqamwsSnXkmAiIiIiIqPRO+Ht2rUrIiIikJWVJZdlZmbigw8+QNeuXQ0aHBERERHRy9J7SvbTTz9Fhw4d4OXlBT8/PwBAYmIiXF1dsWHDBoMHSERERET0MvROeGvVqoVLly5h06ZNuHjxIhwcHDBq1CgMGTIEtra2xoiRiIiIiKjcyrXo1tHREePGjTN0LEREREREBqf3Gl4iIiIiolcJE14iIiIismhMeImIiIjIojHhJSIiIiKLxidFWCB3tUrrn4mIiIgqIp0S3ipVquDGjRuoVq0aKleuDEmSSqz78OFDgwVH5bN1QrDSIRARERGZDZ0S3qVLl8LJyQkAsGzZMmPGQ0RERERkUDolvCNGjND6ZyIiIiIic1euNbyFhYX4+eefkZ6ejsLCQo1tHTp0MEhgRERERESGoHfC+8MPP2Do0KG4c+cOhBAa2yRJQkFBgcGCIyIiIiJ6WXonvOPHj0dAQAC+//57uLu7l3oBGxERERGR0vROeG/evImtW7eiQYMGxoiHiIiIiMig9H7wRNu2bfHzzz8bIxYiIiIiIoPTe4b3nXfewfTp05GWlobmzZvD1tZWY3uLFi0MFhwRERER0cvSO+F98803AQCjR4+WyyRJghCCF60RERERkdnRO+G9ffu2MeIgIiIiIjIKvRNeLy8vY8RBRERERGQUOl20tnv3bjx9+lT+c2kvfa1atQp169aFSqWCv78/Tpw4UWLdo0ePQpKkYq+ffvpJo962bdvg4+MDe3t7+Pj4YMeOHXrHRURERESWQacZ3r59+yItLQ01atRA3759S6yn7xre2NhYTJ06FatWrUJISAi++OIL9OjRA1evXkXt2rVL3O/69etwdnaW31evXl3+8+nTpzFo0CDMnz8f/fr1w44dOzBw4ECcPHkSbdu21Tk2IiIiIrIMknjxcWkm1LZtW7Rq1QpRUVFyWZMmTdC3b19ERkYWq3/06FG8/vrrePToEVxcXLS2OWjQIGRnZ2Pv3r1yWffu3VG5cmXExMToFFd2djbUajWysrI0EmtdhSw4jJTMxwCAWi4OODWzk95tEBEREVHJ9MnX9L4Pr6Hk5eXh/PnzCA0N1SgPDQ1FfHx8qfv6+fnB3d0dnTt3xpEjRzS2nT59ulib3bp1K7XN3NxcZGdna7yIiIiIyDLofNHa48ePcejQIfTu3RsAEBERgdzcXHm7tbU15s+fD5VKpVN7Dx48QEFBAVxdXTXKXV1dkZaWpnUfd3d3rFmzBv7+/sjNzcWGDRvQuXNnHD16FB06dAAApKWl6dUmAERGRmLu3Lk6xU1ERERErxadE97169fju+++kxPezz//HE2bNoWDgwMA4KeffkLNmjUxbdo0vQKQJEnjfdH9fLVp1KgRGjVqJL8PCgpCcnIyFi9eLCe8+rYJPEvew8PD5ffZ2dnw9PTU6ziIiIiIyDzpvKRh06ZNGg+bAICvv/4aR44cwZEjR/DJJ59gy5YtOndcrVo1WFtbF5t5TU9PLzZDW5rAwEDcvHlTfu/m5qZ3m/b29nB2dtZ4EREREZFl0DnhvXHjBry9veX3KpUKVlZ/7t6mTRtcvXpV547t7Ozg7++PuLg4jfK4uDgEBwfr3E5CQgLc3d3l90FBQcXaPHDggF5tEhEREZHl0HlJQ1ZWFmxs/qz+66+/amwvLCzUWNOri/DwcAwfPhwBAQEICgrCmjVrkJSUhPHjxwN4ttQgJSUF69evBwAsW7YMderUQdOmTZGXl4eNGzdi27Zt2LZtm9zmlClT0KFDByxcuBBhYWHYtWsXDh48iJMnT+oVGxERERFZBp0TXg8PD/z3v//VWEP7vEuXLsHDw0OvzgcNGoSMjAzMmzcPqampaNasGfbs2SM/zS01NRVJSUly/by8PMyYMQMpKSlwcHBA06ZN8f3336Nnz55yneDgYGzevBkffvghPvroI9SvXx+xsbG8By8RERFRBaXzfXinTJmCgwcP4vz588XuxPD48WMEBASgS5cuWL58uVECNSXeh5eIiIjIvOmTr+k8w/vBBx9gy5YtaNSoESZPngxvb2/5sb6ff/458vPz8cEHH7x08EREREREhqRzwuvq6or4+HhMmDABM2fORNHEsCRJ6Nq1K1atWqXX3RWIiIiIiExB54QXAOrWrYt9+/bh4cOH+PnnnwEADRo0QJUqVYwSHBERERHRy9Ir4S1SpUoVtGnTxtCxEBEREREZnM734SXdCCGQV1Aov89+/BQXkh5Bx2sDiYiIiMjAmPAa0I37OQhbeQq/5vx5P+Kc3Hz8dVU8wlaewo37OQpGR0RERFQxMeE1kBv3c9A/Kh6X7mZp3X7pbhb6R8Uz6SUiIiIyMSa8BiCEwIxvLiL7SX6p9bKf5OO9by5yeQMRERGRCTHhNYCE5MwSZ3ZfdPFuFhKTM40bEBERERHJmPAaQNzV+3rVP6BnfSIiIiIqPya8BpD1+KlR6xMRERFR+THhNQC1g61R6xMRERFR+THhNYCuPvo9UjlUz/pEREREVH5MeA3Az9MFLTzUOtX19VCjpaeLcQMiIiIiIhkTXgOQJAmLB/jCWVX6k5qdVTb4ZIAvJEkyUWRERERExITXQLxdnbB1QnCJM72+HmpsnRAMb1cnE0dGREREVLEx4TUgb1cn7JoUgupO9nKZk70NdkwMxs5JIUx2iYiIiBRQ+m/wpDdJkmBn/ef/Rzg72MKvdmUFIyIiIiKq2DjDS0REREQWjQkvEREREVk0JrxEREREZNGY8BIRERGRRWPCS0REREQWjQkvEREREVk0JrxEREREZNGY8BIRERGRRWPCS0REREQWjQkvEREREVk0JrxEREREZNGY8BIRERGRRWPCS0REREQWjQkvEREREVk0xRPeVatWoW7dulCpVPD398eJEyd02u/UqVOwsbFBy5YtNcqjo6MhSVKx15MnT4wQPRERERGZO0UT3tjYWEydOhWzZs1CQkIC2rdvjx49eiApKanU/bKysvD222+jc+fOWrc7OzsjNTVV46VSqYxxCERERERk5hRNeJcsWYIxY8Zg7NixaNKkCZYtWwZPT09ERUWVut/f//53DB06FEFBQVq3S5IENzc3jRcRERERVUyKJbx5eXk4f/48QkNDNcpDQ0MRHx9f4n7r1q3DL7/8gtmzZ5dY57fffoOXlxc8PDzQu3dvJCQklBpLbm4usrOzNV5EREREZBkUS3gfPHiAgoICuLq6apS7uroiLS1N6z43b97EzJkzsWnTJtjY2Git07hxY0RHR2P37t2IiYmBSqVCSEgIbt68WWIskZGRUKvV8svT07P8B0ZEREREZkXxi9YkSdJ4L4QoVgYABQUFGDp0KObOnQtvb+8S2wsMDMRbb70FX19ftG/fHlu2bIG3tzc+++yzEveJiIhAVlaW/EpOTi7/ARERERGRWdE+TWoC1apVg7W1dbHZ3PT09GKzvgCQk5ODc+fOISEhAZMnTwYAFBYWQggBGxsbHDhwAJ06dSq2n5WVFVq3bl3qDK+9vT3s7e1f8oiIiIiIyBwpNsNrZ2cHf39/xMXFaZTHxcUhODi4WH1nZ2dcvnwZiYmJ8mv8+PFo1KgREhMT0bZtW639CCGQmJgId3d3oxwHEREREZk3xWZ4ASA8PBzDhw9HQEAAgoKCsGbNGiQlJWH8+PEAni01SElJwfr162FlZYVmzZpp7F+jRg2oVCqN8rlz5yIwMBANGzZEdnY2VqxYgcTERKxcudKkx0ZERERE5kHRhHfQoEHIyMjAvHnzkJqaimbNmmHPnj3w8vICAKSmppZ5T94XZWZmYty4cUhLS4NarYafnx+OHz+ONm3aGOMQiIiIiMjMSUIIoXQQ5iY7OxtqtRpZWVlwdnbWe/+QBYeRkvkYAFDLxQGnZhZfW0xERERE5adPvqb4XRqIiIiIiIyJCS8RERERWTQmvERERERk0ZjwEhEREZFFY8JLRERERBaNCS8RERERWTQmvERERERk0ZjwEhEREZFFY8JLRERERBaNCS8RERERWTQmvERERERk0ZjwEhEREZFFY8JLRERERBaNCS8RERERWTQmvERERERk0ZjwEhEREZFFY8JLRERERBaNCS8RERERWTQmvERERERk0ZjwEhEREZFFY8JLRERERBaNCS8RERERWTQmvERERERk0ZjwEhEREZFFY8JLRERERBaNCS8RERERWTQmvERERERk0ZjwEhEREZFFY8JLRERERBaNCS8RERERWTQmvERERERk0ZjwEhEREZFFUzzhXbVqFerWrQuVSgV/f3+cOHFCp/1OnToFGxsbtGzZsti2bdu2wcfHB/b29vDx8cGOHTsMHDURERERvSoUTXhjY2MxdepUzJo1CwkJCWjfvj169OiBpKSkUvfLysrC22+/jc6dOxfbdvr0aQwaNAjDhw/HxYsXMXz4cAwcOBBnzpwx1mEQERERkRmThBBCqc7btm2LVq1aISoqSi5r0qQJ+vbti8jIyBL3Gzx4MBo2bAhra2vs3LkTiYmJ8rZBgwYhOzsbe/fulcu6d++OypUrIyYmRqe4srOzoVarkZWVBWdnZ72PK2TBYaRkPgYA1HJxwKmZnfRug4iIiIhKpk++ptgMb15eHs6fP4/Q0FCN8tDQUMTHx5e437p16/DLL79g9uzZWrefPn26WJvdunUrtc3c3FxkZ2drvIiIiIjIMiiW8D548AAFBQVwdXXVKHd1dUVaWprWfW7evImZM2di06ZNsLGx0VonLS1NrzYBIDIyEmq1Wn55enrqeTREREREZK4Uv2hNkiSN90KIYmUAUFBQgKFDh2Lu3Lnw9vY2SJtFIiIikJWVJb+Sk5P1OAIiIiIiMmfap0lNoFq1arC2ti4285qenl5shhYAcnJycO7cOSQkJGDy5MkAgMLCQgghYGNjgwMHDqBTp05wc3PTuc0i9vb2sLe3N8BREREREZG5UWyG187ODv7+/oiLi9Moj4uLQ3BwcLH6zs7OuHz5MhITE+XX+PHj0ahRIyQmJqJt27YAgKCgoGJtHjhwQGubRERERGT5FJvhBYDw8HAMHz4cAQEBCAoKwpo1a5CUlITx48cDeLbUICUlBevXr4eVlRWaNWumsX+NGjWgUqk0yqdMmYIOHTpg4cKFCAsLw65du3Dw4EGcPHnSpMdGREREROZB0YR30KBByMjIwLx585CamopmzZphz5498PLyAgCkpqaWeU/eFwUHB2Pz5s348MMP8dFHH6F+/fqIjY2VZ4CJiIiIqGJR9D685or34SUiIiIyb6/EfXiJiIiIiEyBCS8RERERWTQmvERERERk0ZjwEhEREZFFU/QuDZbKXa3S+mciIiIiMj0mvEawdQIfckFERERkLrikgYiIiIgsGhNeIiIiIrJoTHiJiIiIyKIx4SUiIiIii8aEl4iIiIgsGhNeIiIiIrJoTHiJiIiIyKIx4SUiIiIii8aEl4iIiIgsGhNeIiIiIrJofLSwFkIIAEB2drbCkRARERGRNkV5WlHeVhomvFrk5OQAADw9PRWOhIiIiIhKk5OTA7VaXWodSeiSFlcwhYWFuHfvHpycnCBJUrnayM7OhqenJ5KTk+Hs7GzgCM2/f3OIQen+GYN59M8YzKN/xmAe/ZtDDEr3zxjMo39DxCCEQE5ODmrWrAkrq9JX6XKGVwsrKyt4eHgYpC1nZ2fFTiRz6N8cYlC6f8ZgHv0zBvPonzGYR//mEIPS/TMG8+j/ZWMoa2a3CC9aIyIiIiKLxoSXiIiIiCwaE14jsbe3x+zZs2Fvb18h+zeHGJTunzGYR/+MwTz6Zwzm0b85xKB0/4zBPPo3dQy8aI2IiIiILBpneImIiIjIojHhJSIiIiKLxoSXiIiIiCwaE14iIiIismhMeA1ozpw5kCRJ4+Xm5mbUPo8fP44+ffqgZs2akCQJO3fu1NguhMCcOXNQs2ZNODg44C9/+QuuXLli0hhGjhxZbFwCAwMN1n9kZCRat24NJycn1KhRA3379sX169c16hhzHHTp39hjEBUVhRYtWsg37w4KCsLevXvl7aY4D8qKwdhj8KLIyEhIkoSpU6fKZaYYh9L6N/YYlPUdZIrjLysGU50HKSkpeOutt1C1alW89tpraNmyJc6fPy9vN/ZYlNW/scehTp06xdqXJAmTJk0CYJpzoawYjD0G+fn5+PDDD1G3bl04ODigXr16mDdvHgoLC+U6xh4HXWIw9jjk5ORg6tSp8PLygoODA4KDg3H27Fl5uynOhbJiMMX3AhNeA2vatClSU1Pl1+XLl43a3++//w5fX198/vnnWrcvWrQIS5Ysweeff46zZ8/Czc0NXbt2RU5OjsliAIDu3btrjMuePXsM1v+xY8cwadIk/PDDD4iLi0N+fj5CQ0Px+++/y3WMOQ669A8Ydww8PDywYMECnDt3DufOnUOnTp0QFhYmf2mZ4jwoKwbAuGPwvLNnz2LNmjVo0aKFRrkpxqG0/gHjj0Fp30GmOv6yvgeNPQaPHj1CSEgIbG1tsXfvXly9ehWffvopXFxc5DrGHAtd+geMOw5nz57VaDsuLg4AMGDAAACmORfKigEw7hgsXLgQq1evxueff45r165h0aJF+OSTT/DZZ5/JdYw9DrrEABh3HMaOHYu4uDhs2LABly9fRmhoKLp06YKUlBQApjkXyooBMMG/D4IMZvbs2cLX11ex/gGIHTt2yO8LCwuFm5ubWLBggVz25MkToVarxerVq00SgxBCjBgxQoSFhRmlP23S09MFAHHs2DEhhOnH4cX+hTD9GAghROXKlcWXX36pyHnwYgxCmG4McnJyRMOGDUVcXJzo2LGjmDJlihDCdOdBSf0LYfwxKO07yFTHX9b3oCnOg/fff1+0a9euxO3GHouy+hfC9N8JU6ZMEfXr1xeFhYWKfSc8H4MQxh+DXr16idGjR2uU/fWvfxVvvfWWEMI0n4myYhDCuOPwxx9/CGtra/Hdd99plPv6+opZs2aZZAzKikEI03weOMNrYDdv3kTNmjVRt25dDB48GLdu3VIsltu3byMtLQ2hoaFymb29PTp27Ij4+HiTxnL06FHUqFED3t7e+Nvf/ob09HSj9ZWVlQUAqFKlCgDTj8OL/Rcx1RgUFBRg8+bN+P333xEUFKTIefBiDEVMMQaTJk1Cr1690KVLF41yU41DSf0XMfYYlPQdZMrzoKzvQWOPwe7duxEQEIABAwagRo0a8PPzw7///W95u7HHoqz+i5jqOyEvLw8bN27E6NGjIUmSIt8JL8ZQxJhj0K5dOxw6dAg3btwAAFy8eBEnT55Ez549AZjmM1FWDEWMNQ75+fkoKCiASqXSKHdwcMDJkydNMgZlxVDE6J8Ho6bTFcyePXvE1q1bxaVLl+TZHVdXV/HgwQOT9I8XZldPnTolAIiUlBSNen/7299EaGioSWIQQojNmzeL7777Tly+fFns3r1b+Pr6iqZNm4onT54YvP/CwkLRp08fjdkVU46Dtv6FMM0YXLp0STg6Ogpra2uhVqvF999/L4Qw7fGXFIMQphmDmJgY0axZM/H48WMhhNCYYTXFOJTWvxDGH4PSvoNMdR6U9T1oivPA3t5e2Nvbi4iICHHhwgWxevVqoVKpxH/+8x8hhPHPhbL6F8K034uxsbHC2tpaPl4l/m14MQYhjD8GhYWFYubMmUKSJGFjYyMkSRL/+te/5O2mGIeyYhDC+OMQFBQkOnbsKFJSUkR+fr7YsGGDkCRJeHt7m+xcKC0GIUzzeWDCa0S//fabcHV1FZ9++qlJ+isp4b13755GvbFjx4pu3bqZJAZt7t27J2xtbcW2bdsM3v/EiROFl5eXSE5OlstMOQ7a+tfGGGOQm5srbt68Kc6ePStmzpwpqlWrJq5cuWLS4y8pBm0MPQZJSUmiRo0aIjExUS7TlvAaaxzK6l8bY34WhND8DlLi++DFGLQxxhjY2tqKoKAgjbJ33nlHBAYGCiGMfy6U1b82xjwXQkNDRe/eveX3SpwLL8agjaHHICYmRnh4eIiYmBhx6dIlsX79elGlShURHR0thDDNOJQVgzaGHoeff/5ZdOjQQQAQ1tbWonXr1mLYsGGiSZMmJjsXSotBG2N8HrikwYgcHR3RvHlz3Lx5U5H+i66MTktL0yhPT0+Hq6urEiEBANzd3eHl5WXwcXnnnXewe/duHDlyBB4eHnK5qcahpP61McYY2NnZoUGDBggICEBkZCR8fX2xfPlyk54HJcWgjaHH4Pz580hPT4e/vz9sbGxgY2ODY8eOYcWKFbCxsZGP1VjjUFb/BQUFxfYx1mehyPPfQUp9H5T1PWiMMXB3d4ePj49GWZMmTZCUlATA+N8JZfVf0j7GOBfu3LmDgwcPYuzYsXKZqc8FbTFoY+gxeO+99zBz5kwMHjwYzZs3x/DhwzFt2jRERkYCMM04lBWDNoYeh/r16+PYsWP47bffkJycjB9//BFPnz5F3bp1TXYulBaDNsb4PDDhNaLc3Fxcu3YN7u7uivRfdDIXXRkLPFtHdezYMQQHBysSEwBkZGQgOTnZYOMihMDkyZOxfft2HD58uNgHyNjjUFb/2hh6DEqKKzc3V9HzoCgGbQw9Bp07d8bly5eRmJgovwICAjBs2DAkJiaiXr16Rh2Hsvq3trYuto+xz4Pnv4OUOg/K+h40xhiEhIQUuzXgjRs34OXlBcD43wll9a+Nsc6FdevWoUaNGujVq5dcZupzQVsM2hh6DP744w9YWWmmOdbW1vItwUwxDmXFoI2xzgVHR0e4u7vj0aNH2L9/P8LCwkx+LmiLQRujjIHB5opJTJ8+XRw9elTcunVL/PDDD6J3797CyclJ/O9//zNanzk5OSIhIUEkJCQIAGLJkiUiISFB3LlzRwghxIIFC4RarRbbt28Xly9fFkOGDBHu7u4iOzvbJDHk5OSI6dOni/j4eHH79m1x5MgRERQUJGrVqmWwGCZMmCDUarU4evSoSE1NlV9//PGHXMeY41BW/6YYg4iICHH8+HFx+/ZtcenSJfHBBx8IKysrceDAASGEac6D0mIwxRho8+KSAlOMQ0n9m2IMyvoOMsXxlxaDqc6DH3/8UdjY2IiPP/5Y3Lx5U2zatEm89tprYuPGjXIdY45FWf2bahwKCgpE7dq1xfvvv19sm6k+CyXFYIoxGDFihKhVq5b47rvvxO3bt8X27dtFtWrVxD/+8Q+5jrHHoawYTDEO+/btE3v37hW3bt0SBw4cEL6+vqJNmzYiLy9PCGGac6G0GEz1eWDCa0CDBg0S7u7uwtbWVtSsWVP89a9/LXH9oqEcOXJEACj2GjFihBDi2YL52bNnCzc3N2Fvby86dOggLl++bLIY/vjjDxEaGiqqV68ubG1tRe3atcWIESNEUlKSwfrX1jcAsW7dOrmOMcehrP5NMQajR48WXl5ews7OTlSvXl107txZTnaFMM15UFoMphgDbV5MeE0xDiX1b4oxKOs7yBTHX1oMpjwPvv32W9GsWTNhb28vGjduLNasWaOx3dhjUVr/phqH/fv3CwDi+vXrxbaZ6rNQUgymGIPs7GwxZcoUUbt2baFSqUS9evXErFmzRG5urlzH2ONQVgymGIfY2FhRr149YWdnJ9zc3MSkSZNEZmamvN0U50JpMZjq8yAJIYTh5ouJiIiIiMwL1/ASERERkUVjwktEREREFo0JLxERERFZNCa8RERERGTRmPASERERkUVjwktEREREFo0JLxERERFZNCa8RERERGTRmPASESngf//7HyRJQmJiotKhyH766ScEBgZCpVKhZcuWSodDRGQwTHiJqEIaOXIkJEnCggULNMp37twJSZIUikpZs2fPhqOjI65fv45Dhw4pHU6ZJEnCzp07lQ6DiF4BTHiJqMJSqVRYuHAhHj16pHQoBpOXl1fufX/55Re0a9cOXl5eqFq1qgGjIiJSFhNeIqqwunTpAjc3N0RGRpZYZ86cOcV+3l+2bBnq1Kkjvx85ciT69u2Lf/3rX3B1dYWLiwvmzp2L/Px8vPfee6hSpQo8PDywdu3aYu3/9NNPCA4OhkqlQtOmTXH06FGN7VevXkXPnj1RqVIluLq6Yvjw4Xjw4IG8/S9/+QsmT56M8PBwVKtWDV27dtV6HIWFhZg3bx48PDxgb2+Pli1bYt++ffJ2SZJw/vx5zJs3D5IkYc6cOVrb2bdvH9q1awcXFxdUrVoVvXv3xi+//KJRJz4+Hi1btoRKpUJAQIA8a/788g1djuvdd9/FP/7xD1SpUgVubm4aMRWNf79+/SBJkvz+4sWLeP311+Hk5ARnZ2f4+/vj3LlzWo+FiCoOJrxEVGFZW1vjX//6Fz777DPcvXv3pdo6fPgw7t27h+PHj2PJkiWYM2cOevfujcqVK+PMmTMYP348xo8fj+TkZI393nvvPUyfPh0JCQkIDg7GG2+8gYyMDABAamoqOnbsiJYtW+LcuXPYt28f7t+/j4EDB2q08Z///Ac2NjY4deoUvvjiC63xLV++HJ9++ikWL16MS5cuoVu3bnjjjTdw8+ZNua+mTZti+vTpSE1NxYwZM7S28/vvvyM8PBxnz57FoUOHYGVlhX79+qGwsBAAkJOTgz59+qB58+a4cOEC5s+fj/fff1+jDX2Oy9HREWfOnMGiRYswb948xMXFAQDOnj0LAFi3bh1SU1Pl98OGDYOHhwfOnj2L8+fPY+bMmbC1tS39L4+ILJ8gIqqARowYIcLCwoQQQgQGBorRo0cLIYTYsWOHeP6rcfbs2cLX11dj36VLlwovLy+Ntry8vERBQYFc1qhRI9G+fXv5fX5+vnB0dBQxMTFCCCFu374tAIgFCxbIdZ4+fSo8PDzEwoULhRBCfPTRRyI0NFSj7+TkZAFAXL9+XQghRMeOHUXLli3LPN6aNWuKjz/+WKOsdevWYuLEifJ7X19fMXv27DLbel56eroAIC5fviyEECIqKkpUrVpVPH78WK7z73//WwAQCQkJeh1Xu3btisX7/vvvy+8BiB07dmjUcXJyEtHR0XodAxFZPs7wElGFt3DhQvznP//B1atXy91G06ZNYWX151eqq6srmjdvLr+3trZG1apVkZ6errFfUFCQ/GcbGxsEBATg2rVrAIDz58/jyJEjqFSpkvxq3LgxAGgsIwgICCg1tuzsbNy7dw8hISEa5SEhIXJfuvrll18wdOhQ1KtXD87Ozqhbty4AICkpCQBw/fp1tGjRAiqVSt6nTZs2Gm3oelwtWrTQ2M/d3b3Y+L0oPDwcY8eORZcuXbBgwYJiyy2IqGJiwktEFV6HDh3QrVs3fPDBB8W2WVlZQQihUfb06dNi9V782VySJK1lRT/9l6boLhGFhYXo06cPEhMTNV43b95Ehw4d5PqOjo5ltvl8u0WEEHrfkaJPnz7IyMjAv//9b5w5cwZnzpwB8OfFctrafHH8dD2u8ozfnDlzcOXKFfTq1QuHDx+Gj48PduzYodcxEpHlYcJLRARgwYIF+PbbbxEfH69RXr16daSlpWkkbYa8d+4PP/wg/zk/Px/nz5+XZztbtWqFK1euoE6dOmjQoIHGS9ckFwCcnZ1Rs2ZNnDx5UqM8Pj4eTZo00bmdjIwMXLt2DR9++CE6d+6MJk2aFLvDRePGjXHp0iXk5ubKZS9eNGao47K1tUVBQUGxcm9vb0ybNg0HDhzAX//6V6xbt07nNonIMjHhJSIC0Lx5cwwbNgyfffaZRvlf/vIX/Prrr1i0aBF++eUXrFy5Env37jVYvytXrsSOHTvw008/YdKkSXj06BFGjx4NAJg0aRIePnyIIUOG4Mcff8StW7dw4MABjB49WmuiV5r33nsPCxcuRGxsLK5fv46ZM2ciMTERU6ZM0bmNypUro2rVqlizZg1+/vlnHD58GOHh4Rp1hg4disLCQowbNw7Xrl3D/v37sXjxYgB/zjAb6rjq1KmDQ4cOIS0tDY8ePcLjx48xefJkHD16FHfu3MGpU6dw9uxZvZJ6IrJMTHiJiP6/+fPnF/v5vUmTJli1ahVWrlwJX19f/PjjjyXewaA8FixYgIULF8LX1xcnTpzArl27UK1aNQBAzZo1cerUKRQUFKBbt25o1qwZpkyZArVarbFeWBfvvvsupk+fjunTp6N58+bYt28fdu/ejYYNG+rchpWVFTZv3ozz58+jWbNmmDZtGj755BONOs7Ozvj222+RmJiIli1bYtasWfi///s/AJDX9RrquD799FPExcXB09MTfn5+sLa2RkZGBt5++214e3tj4MCB6NGjB+bOnatzm0RkmSTx4rc7ERGRAW3atAmjRo1CVlYWHBwclA6HiCogG6UDICIiy7J+/XrUq1cPtWrVwsWLF/H+++9j4MCBTHaJSDFMeImIyKDS0tLwf//3f0hLS4O7uzsGDBiAjz/+WOmwiKgC45IGIiIiIrJovGiNiIiIiCwaE14iIiIismhMeImIiIjIojHhJSIiIiKLxoSXiIiIiCwaE14iIiIismhMeImIiIjIojHhJSIiIiKL9v8AaoojncLvrjIAAAAASUVORK5CYII=", + "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"