From c8873cb84ebfbb6f2cb79063dc6ba13c8041d61e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=ABl=20Foramitti?= <57440945+JoelForamitti@users.noreply.github.com> Date: Fri, 27 Nov 2020 17:24:19 +0100 Subject: [PATCH] New file names 2 --- docs/agentpy_button_network.ipynb | 167 + docs/agentpy_forest_fire.ipynb | 18985 ++++++++ docs/agentpy_virus_spread.ipynb | 62208 +++++++++++++++++++++++++++ docs/agentpy_wealth_transfer.ipynb | 300 + 4 files changed, 81660 insertions(+) create mode 100644 docs/agentpy_button_network.ipynb create mode 100644 docs/agentpy_forest_fire.ipynb create mode 100644 docs/agentpy_virus_spread.ipynb create mode 100644 docs/agentpy_wealth_transfer.ipynb diff --git a/docs/agentpy_button_network.ipynb b/docs/agentpy_button_network.ipynb new file mode 100644 index 0000000..7ab276e --- /dev/null +++ b/docs/agentpy_button_network.ipynb @@ -0,0 +1,167 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Button network\n", + "\n", + "This is a demonstration of the [agentpy](https://agentpy.readthedocs.io) package, presenting an agent-based model of randomly connecting buttons. \n", + "It shows how to work with networks and how to visualize averaged time-series for discrete parameter samples. \n", + "\n", + "A [similar model](http://agentbase.org/model.html?f4c4388138450bdf9732) has been built by Wybo Wiersma in [Agentbase](http://agentbase.org/model.html?f4c4388138450bdf9732), allowing for a comparison between the two frameworks. The idea for the model is based on the following analogy from [Stuart Kauffman](http://www.pbs.org/lifebeyondearth/resources/intkauffmanpop.html): \n", + "\n", + "> \"Suppose you take 10,000 buttons and spread them out on a hardwood floor. You have a large spool of red thread. Now, what you do is you pick up a random pair of buttons and you tie them together with a piece of red thread. Put them down and pick up another random pair of buttons and tie them together with a red thread, and you just keep doing this. Every now and then lift up a button and see how many buttons you've lifted with your first button. A connective cluster of buttons is called a cluster or a component. When you have 10,000 buttons and only a few threads that tie them together, most of the times you'd pick up a button you'll pick up a single button. \n", + ">\n", + ">As the ratio of threads to buttons increases, you're going to start to get larger clusters, three or four buttons tied together; then larger and larger clusters. At some point, you will have a number of intermediate clusters, and when you add a few more threads, you'll have linked up the intermediate-sized clusters into one giant cluster.\n", + ">\n", + ">So that if you plot on an axis, the ratio of threads to buttons: 10,000 buttons and no threads; 10,000 buttons and 5,000 threads; and so on, you'll get a curve that is flat, and then all of a sudden it shoots up when you get this giant cluster. This steep curve is in fact evidence of a phase transition.\n", + ">\n", + ">If there were an infinite number of threads and an infinite number of buttons and one just tuned the ratios, this would be a step function; it would come up in a sudden jump. So it's a phase transition like ice freezing.\n", + ">\n", + ">Now, the image you should take away from this is if you connect enough buttons all of a sudden they all go connected. To think about the origin of life, we have to think about the same thing.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import libraries\n", + "\n", + "import agentpy as ap\n", + "import networkx as nx\n", + "import seaborn as sns\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Define the model\n", + "\n", + "class button_model(ap.Model):\n", + " \n", + " def setup(self):\n", + " \n", + " # Create a graph with n agents\n", + " self.add_network('buttons')\n", + " self.buttons.add_agents(self.p.n)\n", + " self.threads = 0\n", + " \n", + " def update(self):\n", + " \n", + " # Record size of the biggest cluster\n", + " clusters = nx.connected_components(self.buttons.graph)\n", + " max_cluster_size = max([len(g) for g in clusters]) / self.p.n\n", + " self.record('max_cluster_size', max_cluster_size)\n", + " \n", + " # Record threads to button ratio\n", + " self.record('threads_to_button', self.threads / self.p.n)\n", + " \n", + " def step(self):\n", + " \n", + " # Create random edges based on parameters\n", + " for _ in range(int(self.p.n * self.p.speed)): \n", + " self.buttons.add_edge(*self.agents.random(2))\n", + " self.threads += 1 " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Define parameter ranges\n", + "\n", + "parameter_ranges = {\n", + " 'steps': 30, # Number of simulation steps\n", + " 'speed': 0.05, # Speed of connections per step\n", + " 'n': (10,100,500,1000,10000) # Number of agents, given in a discrete range\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scheduled runs: 125\n", + "Completed: 125, estimated time remaining: 0:00:00\n", + "Run time: 0:01:28.365157\n", + "Simulation finished\n" + ] + } + ], + "source": [ + "# Perform simulation\n", + "\n", + "sample = ap.sample_discrete(parameter_ranges) # Create sample for different values of n\n", + "exp = ap.Experiment(button_model, sample, iterations = 25, record = True) # Keep dynamic variables\n", + "results = exp.run() # Perform 125 seperate simulations ( 5 parameter combinations * 25 repetitions )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot results\n", + "\n", + "data = results.arrange(('variables', 'parameters')) # Create plotting data\n", + "ax = sns.lineplot(data=data, x='threads_to_button', y='max_cluster_size', hue='n')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that, in line with Kauffman's argumentation, the variable stays low and then shoots up quite suddenly at a treshold of 0.5 if the number of buttons is high. However, in contrast to Kauffman's claim, the function does not converge towards a step function as the steepness of the curve declines later on independent of the number of buttons." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/agentpy_forest_fire.ipynb b/docs/agentpy_forest_fire.ipynb new file mode 100644 index 0000000..fa537fb --- /dev/null +++ b/docs/agentpy_forest_fire.ipynb @@ -0,0 +1,18985 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Forest fire" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a demonstration of the [agentpy](https://agentpy.readthedocs.io) package, presenting an agent-based model that simulates a forest fire. \n", + "It shows how to to work with a spacial grid, create animations, and perform a parameter sweep. \n", + "\n", + "The [original model](http://ccl.northwestern.edu/netlogo/models/FireSimple) has been designed in Netlogo by Uri Wilensky and William Rand (2015), who describe it as follows:\n", + "\n", + "> \"This model simulates the spread of a fire through a forest. It shows that the fire's chance of reaching the right edge of the forest depends critically on the density of trees. This is an example of a common feature of complex systems, the presence of a non-linear threshold or critical parameter. [...] \n", + ">\n", + "> The fire starts on the left edge of the forest, and spreads to neighboring trees. The fire spreads in four directions: north, east, south, and west.\n", + ">\n", + ">The model assumes there is no wind. So, the fire must have trees along its path in order to advance. That is, the fire cannot skip over an unwooded area (patch), so such a patch blocks the fire's motion in that direction.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import libraries\n", + "\n", + "import agentpy as ap\n", + "import matplotlib.pyplot as plt # Plotting library\n", + "import seaborn as sns # Statistical data visualization\n", + "\n", + "from IPython.display import HTML # To display animations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model definition" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class forest_model(ap.Model):\n", + " \n", + " def setup(self):\n", + " \n", + " # Create grid (forest)\n", + " x = y = self.p.size # Access parameter\n", + " self.add_grid('forest', shape=(x,y))\n", + " \n", + " # Create agents (trees) \n", + " n_trees = int(self.p.density * x * y)\n", + " self.forest.add_agents(n_trees, random=True)\n", + " \n", + " # Initiate a dynamic variable for all trees\n", + " # Condition 0: Alive, 1: Burning, 2: Burned\n", + " self.agents.condition = 0 \n", + " \n", + " # Start a fire from the left side of the grid\n", + " unfortunate_trees = self.forest.area([(0,x),(0,0)])\n", + " unfortunate_trees.condition = 1 \n", + " \n", + " def step(self):\n", + " \n", + " # Select burning trees\n", + " burning_trees = self.agents(self.agents.condition == 1)\n", + "\n", + " # Spread fire \n", + " for agent in burning_trees:\n", + " for neighbor in agent.neighbors():\n", + " if neighbor.condition == 0:\n", + " neighbor.condition = 1 # Neighbor starts burning\n", + " agent.condition = 2 # Tree burns out \n", + " \n", + " # Stop simulation if no fire is left\n", + " if len(burning_trees) == 0: self.stop()\n", + " \n", + " def end(self):\n", + " \n", + " # Document a measure at the end of the simulation\n", + " burned_trees = len(self.agents(self.agents.condition == 2)) / len(self.agents)\n", + " self.measure('Percentage of burned trees', burned_trees )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Single-run animation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Define parameters\n", + "\n", + "parameters = {\n", + " 'density': 0.6, # Percentage of grid covered by trees\n", + " 'size': 100 # Height and length of the grid\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create single-run animation\n", + "\n", + "def animation_plot(model,ax):\n", + " \n", + " color_dict = { 'empty': 'w', 0:'g' , 1:'r', 2:'grey'}\n", + " ap.gridplot(model,ax,'forest','condition',color_dict)\n", + "\n", + "fig, ax = plt.subplots(figsize=(7,7)) \n", + "animation = ap.animate(forest_model, parameters, fig, ax, animation_plot)\n", + "HTML(animation.to_jshtml())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parameter sweep" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare parameter sample\n", + "# Arranges 50 values for density from 0.1 to 1\n", + "\n", + "parameter_ranges = {\n", + " 'density': (0.1,1), \n", + " 'size': 100 \n", + " }\n", + "\n", + "sample = ap.sample(parameter_ranges, n=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scheduled runs: 1000\n", + "Completed: 1000, estimated time remaining: 0:00:00\n", + "Run time: 0:11:06.679322\n", + "Simulation finished\n", + "Data saved to ap_output/forest_model_1\n" + ] + } + ], + "source": [ + "# Perform experiment\n", + "# Repeats simulation 20 times for each value of density\n", + "\n", + "exp = ap.Experiment(forest_model, sample, iterations = 20)\n", + "results = exp.run()\n", + "results.save()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading from directory ap_output/forest_model_1/\n", + "Loading log.json - Successful\n", + "Loading measures.csv - Successful\n", + "Loading parameters_fixed.json - Successful\n", + "Loading parameters_varied.csv - Successful\n" + ] + } + ], + "source": [ + "# Load saved output data\n", + "\n", + "results = ap.load('forest_model')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot sensitivity\n", + "# Every point shows average over 50 runs\n", + "\n", + "data = results.arrange(('measures','parameters')) # Create plotting data\n", + "ax = sns.lineplot(data=data, x='density', y='Percentage of burned trees')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "Wilensky, U. & Rand, W. (2015). Introduction to Agent-Based Modeling: Modeling Natural, Social and Engineered Complex Systems with NetLogo. Cambridge, MA. MIT Press." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/agentpy_virus_spread.ipynb b/docs/agentpy_virus_spread.ipynb new file mode 100644 index 0000000..ed87f97 --- /dev/null +++ b/docs/agentpy_virus_spread.ipynb @@ -0,0 +1,62208 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Virus spread" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a demonstration of the [agentpy](https://agentpy.readthedocs.io) package, presenting an agent-based model that simulates the propagation of a disease. \n", + "It shows how to create and visualize networks, plot interactive output, and perform a Sobol sensitivity analysis. \n", + "\n", + "The model works as follows. Agents can be in one of three conditions: susceptible to the disease (S), infected (I), or recovered (R). They are connected to other agents through a small-world network of peers. At every time-step, infected agents can infect their peers or recover from the disease based on random chance." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To start, we import agentpy and additional libraries:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import agentpy as ap\n", + "\n", + "import matplotlib.pyplot as plt \n", + "import seaborn as sns # Statistical data visualization\n", + "import networkx as nx # Network analysis\n", + "from random import random " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the model" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "We define a new agent type ``human`` by creating a subclass of :class:`Agent`.\n", + "There are two methods in this class:\n", + "\n", + "- :func:`Agent.setup` is called automatically when an agent is created, \n", + " and initializes a variable ``condition``. \n", + "- ``being_sick()`` causes the agent to spread the disease to its peers \n", + " and/or recover based on random chance. \n", + "\n", + "There are further three tools that are used here:\n", + "\n", + "- ``Agent.p`` is used to access model parameters\n", + "- :func:`Agent.neighbors()` returns a list of the agents' peers in the network\n", + "- :func:`random()` returns a uniform random draw between 0 and 1" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class human(ap.Agent):\n", + " \n", + " def setup(self): \n", + " \n", + " self.condition = 0 # Susceptible = 0, Infected = 1, Recovered = 2\n", + " \n", + " def being_sick(self):\n", + " \n", + " # Infect susceptible peers if succesfull\n", + " for peer in self.neighbors('peer_network'): \n", + " if peer.condition == 0 and self.p.infection_chance > random():\n", + " peer.condition = 1\n", + " \n", + " # Recover if succesfull\n", + " if self.p.recovery_chance > random(): \n", + " self.condition = 2 " + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "Next, we define our model ``virus_model`` by creating a subclass \n", + "of :class:`Model` with the following four methods:\n", + "\n", + "- :func:`Model.setup` initializes the agents and network of the model \n", + "- :func:`Model.step` and defines the models' events per simulation step\n", + "- :func:`Model.update` records variables after setup and each step\n", + "- :func:`Model.end` records evaluation measures at the end" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class virus_model(ap.Model):\n", + " \n", + " def setup(self):\n", + " \n", + " # Set parameter values to integer\n", + " p = self.p.population = int(self.p.population)\n", + " n = self.p.number_of_neighbors = int(self.p.number_of_neighbors)\n", + " \n", + " # Create a small-world network with a networkx generator function\n", + " small_world = nx.watts_strogatz_graph(p, n, self.p.network_randomness)\n", + " self.add_network('peer_network', graph = small_world ) \n", + " \n", + " # Add human agents to network and map them to existing nodes\n", + " self.peer_network.add_agents(p, human, map_to_nodes = True)\n", + " \n", + " # Infect a random share of the population\n", + " I0 = int(self.p.initial_infections * p)\n", + " self.agents.random(I0).condition = 1 \n", + "\n", + " def update(self): \n", + " \n", + " # Record share of agents with each condition\n", + " for i,c in enumerate(('S','I','R')): \n", + " self[c] = (len(self.agents(self.agents.condition == i)) \n", + " / self.p.population) \n", + " self.record(c)\n", + " \n", + " # Stop simulation if disease is gone\n", + " if self.I == 0:\n", + " self.stop()\n", + " \n", + " def step(self): \n", + " \n", + " # Call 'being_sick' for infected agents\n", + " self.agents(self.agents.condition==1).being_sick()\n", + " \n", + " def end(self): \n", + " \n", + " # Record final evaluation measures\n", + " self.measure('Total Infection Rate', self.I + self.R) \n", + " self.measure('Peak Infection Rate', max(self.log['I']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running a simulation" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "To run our model, we define a dictionary with our parameters. \n", + "We then create a new instance of our model, passing the parameters as an argument, \n", + "and use the method :func:`Model.run` to perform the simulation and return it's output. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed: 63 steps\n", + "Run time: 0:00:00.632875\n", + "Simulation finished\n" + ] + } + ], + "source": [ + "parameters = {\n", + " \n", + " 'population':1000,\n", + " 'infection_chance':0.3,\n", + " 'recovery_chance':0.1,\n", + " 'initial_infections':0.1,\n", + " 'number_of_neighbors':2,\n", + " 'network_randomness':0.5\n", + " \n", + "}\n", + "\n", + "model = virus_model(parameters)\n", + "results = model.run() # returns model.output" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyzing results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The results are given as a dictionary of recorded data and pandas dataframes:\n", + "\n", + "- `log` holds information about the model and simulation performance.\n", + "- `model_vars` holds a dataframe with dynamic model variables that are recorded at different time-steps.\n", + "- `measures` holds a dataframe with evaluation measures that are recoreded only once per simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DataDict {\n", + "'log': Dictionary with 4 keys\n", + "'parameters': Dictionary with 6 keys\n", + "'measures': DataFrame with 2 variables and 1 row\n", + "'variables': DataFrame with 3 variables and 64 rows }" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize the evolution of our `model_vars`, we create a matplotlib plot function `virus_stackplot()`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def virus_stackplot(data,ax):\n", + " \n", + " x = data.index.get_level_values('t')\n", + " y = [data[var] for var in ['I','S','R']]\n", + " \n", + " ax.stackplot(x, y, labels=['Infected','Susceptible','Recovered'], colors = ['r','b','g']) \n", + " \n", + " ax.legend()\n", + " ax.grid(False)\n", + " ax.set_xlim(0,max(1,len(x)-1))\n", + " ax.set_ylim(0,1)\n", + " ax.set_xlabel(\"Time steps\")\n", + " ax.set_ylabel(\"Percentage of population\")\n", + "\n", + "sns.set() # Set seaborn style\n", + "fig, ax = plt.subplots() # Initialize plot\n", + "virus_stackplot(results.variables, ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Animating a simulation" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "We can also observe the development of our model over time. We define a function ``animation_plot()`` that takes a model instance and displays the previous stackplot together with a network graph for a passed model instance. The function :func:`animate` will call this plot function for every time-step and return a matplotlib animation object." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def animation_plot(m,axs):\n", + " \n", + " ax1,ax2 = axs\n", + " \n", + " # Plot stackplot on first axis\n", + " virus_stackplot(m.output.variables, ax1)\n", + " \n", + " # Plot network on second axis\n", + " color_dict = { 0 : 'b', 1 : 'r', 2 : 'g' }\n", + " colors = [ color_dict[c] for c in m.agents.condition ]\n", + " nx.draw_circular(m.peer_network.graph, node_color=colors, node_size=50, ax=ax2)\n", + "\n", + "sns.set() # Set seaborn style\n", + "fig, axs = plt.subplots(1,2,figsize=(8,4)) # Prepare figure \n", + "parameters['population'] = 50 # Reduce population for better visibility \n", + "animation = ap.animate(virus_model, parameters, fig, axs, animation_plot)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Jupyter, we can use `.to_jshtml()` and `HTML` to display the animation object directly." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import HTML\n", + "HTML(animation.to_jshtml()) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interactive parameter variation\n", + "\n", + "To experiment with different parameter values, we define a dictionary `param_ranges`, where we declare tuples with a minimum and maximum value for parameters that we want to vary, as well as a function `interactive_plot()` that takes the model output and displays both our measures and variables." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "param_ranges = {\n", + " \n", + " 'population':(100,1000),\n", + " 'infection_chance':(0,1),\n", + " 'recovery_chance':(0,1),\n", + " 'initial_infections':0.1,\n", + " 'number_of_neighbors':2,\n", + " 'network_randomness':(0,1)\n", + " \n", + "}\n", + "\n", + "def interactive_plot(output):\n", + " \n", + " # Display measures\n", + " print(output.measures)\n", + " \n", + " # Display model_vars\n", + " fig,ax = plt.subplots()\n", + " virus_stackplot(output.variables,ax) " + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "In Jupyter, we can then use the function :func:`interactive` to display our plot with a widget to change parameter values." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a5d6846ccae046559fb44e6e6e9b6bed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(VBox(children=(FloatSlider(value=450.0, description='population', layout=Layout(width='300px'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ap.interactive(virus_model,param_ranges,interactive_plot)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experiment with multiple runs" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "To look into parameter variations in more detail, we use :func:`sample_saltelli` to create a sample of different parameter combinations. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "sample = ap.sample_saltelli(param_ranges, N=500)" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "We then create an :class:`Experiment` that runs our model repeatedly over the whole sample." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scheduled runs: 5000\n", + "Completed: 5000, estimated time remaining: 0:00:00\n", + "Run time: 0:11:07.044520\n", + "Simulation finished\n" + ] + } + ], + "source": [ + "exp = ap.Experiment(virus_model, sample)\n", + "results = exp.run()" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "We can save and load agentpy output data with :func:`DataDict.save()` and :func:`load()`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data saved to ap_output/virus_model_1\n" + ] + } + ], + "source": [ + "results.save() # Alternative: ap.save(results)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading from directory ap_output/virus_model_1/\n", + "Loading log.json - Successful\n", + "Loading measures.csv - Successful\n", + "Loading parameters_fixed.json - Successful\n", + "Loading parameters_varied.csv - Successful\n", + "Loading variables.csv - Successful\n" + ] + } + ], + "source": [ + "results = ap.load('virus_model') # Load data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The measures in our data_dict now hold one row for each simulation run." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DataDict {\n", + "'log': Dictionary with 5 keys\n", + "'measures': DataFrame with 2 variables and 5000 rows\n", + "'parameters': DataDict {\n", + " 'fixed': Dictionary with 2 keys\n", + " 'varied': DataFrame with 4 variables and 5000 rows }\n", + "'variables': DataFrame with 3 variables and 322792 rows }" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "We can use standard functions of the pandas library like :meth:`pandas.DataFrame.hist` to look at summary statistics." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "results.measures.hist()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sensitivity analysis" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "The function :func:`sobol_sensitivity()` calculates sobol sensitivity indices for the passed results and parameter ranges, using the [SAlib]( https://salib.readthedocs.io/en/latest/basics.html) package. This adds two new categories to our results:\n", + "\n", + "- ``sensitivity`` returns first-order sobol sensitivity indices\n", + "- ``sensitivity_conf`` returns confidence ranges for the above indices" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
S1ST
measureparameter
Total Infection Ratepopulation0.0167590.016685
infection_chance0.7328920.795090
recovery_chance0.1835620.269121
network_randomness0.0154350.025575
Peak Infection Ratepopulation0.0171870.013899
infection_chance0.2102700.312987
recovery_chance0.6181140.769999
network_randomness0.0148800.024320
\n", + "
" + ], + "text/plain": [ + " S1 ST\n", + "measure parameter \n", + "Total Infection Rate population 0.016759 0.016685\n", + " infection_chance 0.732892 0.795090\n", + " recovery_chance 0.183562 0.269121\n", + " network_randomness 0.015435 0.025575\n", + "Peak Infection Rate population 0.017187 0.013899\n", + " infection_chance 0.210270 0.312987\n", + " recovery_chance 0.618114 0.769999\n", + " network_randomness 0.014880 0.024320" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ap.sobol_sensitivity( results, param_ranges )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use the pandas functionalities to create a bar plot `plot_sobol_indices()` that visualizes our sensitivities." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_sobol_indices(results):\n", + " \n", + " sns.set()\n", + " fig, axs = plt.subplots(1,2,figsize=(10,5))\n", + "\n", + " SI = results.sensitivity.groupby(by='measure')\n", + " SIT = results.sensitivity_conf.groupby(by='measure')\n", + "\n", + " for (key,si),(_,err),ax in zip(SI, SIT, axs):\n", + "\n", + " si = si.droplevel('measure')\n", + " err = err.droplevel('measure')\n", + " si.plot.bar(yerr=err,title=key,ax=ax)\n", + " \n", + "plot_sobol_indices(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, we can also display the sensitivities by plotting average evaluation measures over our parameter variations. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def virus_scatterplot(results):\n", + " \n", + " fig, axs = plt.subplots(2,2,figsize=(8,8))\n", + " \n", + " data = results.arrange(('measures','parameters'))\n", + " params = results.parameters.varied.keys() # List of varied parameter keys\n", + " axs = [i for j in axs for i in j] # Flatten axis list\n", + " \n", + " for x,ax in zip(params,axs):\n", + " for y in results.measures.columns:\n", + " sns.regplot(x=x, y=y, data=data, ax = ax, ci=99, x_bins=15, fit_reg=False, label=y)\n", + " \n", + " ax.set_ylim(0,1)\n", + " ax.set_ylabel('')\n", + " ax.legend()\n", + " \n", + " plt.tight_layout()\n", + "\n", + "virus_scatterplot(results)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/agentpy_wealth_transfer.ipynb b/docs/agentpy_wealth_transfer.ipynb new file mode 100644 index 0000000..2619410 --- /dev/null +++ b/docs/agentpy_wealth_transfer.ipynb @@ -0,0 +1,300 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Wealth transfer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a demonstration on how to create a simple agent-based model with the [agentpy](https://agentpy.readthedocs.io) package. \n", + "It shows how to create a custom agent and model class, run a model, and visualize output data.\n", + "\n", + "The model explores the distribution of wealth under a trading population of agents. We will see that their random interaction will create an inequality of wealth that follows a [Boltzmann distribution](http://www.phys.ufl.edu/~meisel/Boltzmann.pdf).\n", + "\n", + "The original version of this model been written in [MESA](https://mesa.readthedocs.io/) (Project Mesa Team, 2016), and can be found [here](https://mesa.readthedocs.io/en/master/tutorials/intro_tutorial.html). This adaption of the same model for agentpy is meant to provide a comparison between the two frameworks." + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "To start, we import agentpy and numpy:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import agentpy as ap\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "We then define a new agent type ``wealth_agent`` as a subcluss of :class:`Agent`.\n", + "Each agent starts with one unit of `wealth`.\n", + "When `wealth_transfer()` is called, the agent selects another agent at random \n", + "and gives them one unit of their own wealth if they have one to spare." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class wealth_agent(ap.Agent):\n", + "\n", + " \"\"\" An agent with wealth \"\"\"\n", + "\n", + " def setup(self):\n", + "\n", + " self.wealth = 1\n", + "\n", + " def wealth_transfer(self):\n", + "\n", + " if self.wealth > 0:\n", + "\n", + " partner = self.model.agents.random()\n", + " partner.wealth += 1\n", + " self.wealth -= 1" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "Next, we define a method to calculate the Gini Coefficient, \n", + "which will measure the inequality among our agents." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def gini(x):\n", + "\n", + " \"\"\" Calculate Gini Coefficient \"\"\"\n", + " # By Warren Weckesser https://stackoverflow.com/a/39513799\n", + "\n", + " mad = np.abs(np.subtract.outer(x, x)).mean() # Mean absolute difference\n", + " rmad = mad / np.mean(x) # Relative mean absolute difference\n", + " return 0.5 * rmad " + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "Finally, we define our model as a subclass of :class:`Model`. In :func:`Model.setup`, we define how many agents should be created at the beginning of the simulation. In :func:`Model.step`, we define that at every time-step all agents will perform the action `wealth_transfer`. In :func:`Model.update`, we calculate and record the current Gini Coefficient`. And in :func:`Model.end`, we further record the wealth of each agent." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class wealth_model(ap.Model):\n", + "\n", + " \"\"\" A simple model of random wealth transfers \"\"\"\n", + "\n", + " def setup(self):\n", + "\n", + " self.add_agents(self.p.agents, wealth_agent)\n", + "\n", + " def step(self):\n", + "\n", + " self.agents.wealth_transfer()\n", + "\n", + " def update(self):\n", + "\n", + " self.record('Gini Coefficient', gini(self.agents.wealth))\n", + "\n", + " def end(self):\n", + "\n", + " self.agents.record('wealth')" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "To run a simulation, we define a dictionary of parameters that defines the number of agents and the number of steps that the model will run." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + " 'agents': 100,\n", + " 'steps': 100\n", + "}" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "To perform a simulation, we initialize our model with these parameters and call the method :class:`Model.run`, which returns a :class:`DataDict` of our recorded variables and measures." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed: 100 steps\n", + "Run time: 0:00:00.464867\n", + "Simulation finished\n" + ] + } + ], + "source": [ + "model = wealth_model(parameters)\n", + "results = model.run()" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "To visualize the evolution of our Gini Coefficient, \n", + "we can use :meth:`pandas.DataFrame.plot`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data = results.variables.model\n", + "ax = data.xs('model').plot()" + ] + }, + { + "cell_type": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "And to visualize the final distribution of wealth, \n", + "we can use :meth:`pandas.DataFrame.hist`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAATeUlEQVR4nO3df7DddX3n8eeLQBUT5EfBTAQ1WZe1dWXXyq1bZMYmKk6qCJTBHVl1wWGb6dRaWnEs7rZ1O65T251YW3dnd6k6YUdqZIAKC2sti1wYrD9IFAwYLdQiFbPJKhC4LKtG3vvH+aZcQn58c2++53Dv5/mYuXPO93vO93zfH8h95ZPP+Xw/31QVkqR2HDbpAiRJ42XwS1JjDH5JaozBL0mNMfglqTGHT7qAPo4//vhauXLlnI597LHHWLp06aEt6BnONrfBNrdhPm3evHnz96vqhD33L4jgX7lyJZs2bZrTsdPT06xevfrQFvQMZ5vbYJvbMJ82J/nO3vY71CNJjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY1ZEFfuzseWB3Zy4aU3TLqMsdqwtq1L2iUdHHv8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4Jakxgwd/kiVJvpbk+m77uCQ3Jrmnezx26BokSU8aR4//YmDrrO1LgZuq6mTgpm5bkjQmgwZ/kpOANwIfm7X7bODy7vnlwDlD1iBJeqqhe/wfAd4LPDFr3/Kq2gbQPT5v4BokSbOkqob54ORM4A1V9WtJVgPvqaozkzxcVcfMet9DVfW0cf4k64B1AMuXLz9148aNc6pjx4M72f74nA5dsFYdvYRly5ZNuoyxmpmZsc0NsM0HZ82aNZuramrP/UPec/d04KwkbwCeDTw3ySeB7UlWVNW2JCuAHXs7uKouAy4DmJqaqtWrV8+piI9ecS3rtyz6Wws/xYa1S5nrf6+Fanp62jY3wDYfGoMN9VTV+6rqpKpaCbwF+HxVvQ24Drige9sFwLVD1SBJerpJzOP/EHBGknuAM7ptSdKYjGUMpKqmgenu+Q+A147jvJKkp/PKXUlqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGnPA4E/y4iTP6p6vTvIbSY4ZvDJJ0iD69PivBn6S5B8DHwdWAX8+aFWSpMH0Cf4nqmoX8MvAR6rqt4AVw5YlSRpKn+D/cZLzgQuA67t9RwxXkiRpSH2C/x3AacAHq+rvkqwCPjlsWZKkoRze4z1nVNVv7N7owv/xAWuSJA2oT/BfAPzJHvsu3Ms+PUNseWAnF156w6TLGKsNa5dOugRpwdhn8Hfj+v8KWJXkulkvHQX84EAfnOTZwK3As7rzXFVV709yHPBpYCVwH/Avq+qhuTZAknRw9tfj/2tgG3A8sH7W/keBr/f47B8Cr6mqmSRHALcl+SxwLnBTVX0oyaXApcBvz6l6SdJB22fwV9V3gO8w+mL3oFVVATPd5hHdTwFnA6u7/ZcD0xj8kjQ2fa7cPTfJPUl2JnkkyaNJHunz4UmWJLkD2AHcWFVfBpZX1TaA7vF586hfknSQMuqY7+cNyb3Am6pq65xPMlri4S+AdwG3VdUxs157qKqO3csx64B1AMuXLz9148aNczr3jgd3sr2xOUjLj6S5Nq86egnLli2bdBljNTMzY5sbMJ82r1mzZnNVTe25v8+snu3zCX2Aqno4yTSwFtieZEVVbUuygtG/BvZ2zGXAZQBTU1O1evXqOZ37o1dcy/otfZq5eFxyyq7m2rxh7VLm+mdkoZqenrbNDRiizX0u4NqU5NNJzu+Gfc5Ncu6BDkpywu7F3JIcCbwO+CZwHaMponSP186tdEnSXPTpFj4X+L/A62ftK+CaAxy3Arg8yRJGf8FcWVXXJ/kicGWSi4D7gTcffNmSpLk6YPBX1Tvm8sFV9XXg5/ay/wfAa+fymZKk+eszq+efJLkpyV3d9j9L8jvDlyZJGkKfMf4/A94H/Bj+oSf/liGLkiQNp0/wP6eqvrLHvl1DFCNJGl6f4P9+khcz+kKXJOcxWspBkrQA9ZnV805G8+l/JskDwN8Bbxu0KknSYPrM6vk28LokS4HDqurR4cuSJA3lgMGf5N17bAPsBDZX1R3DlCVJGkqfMf4p4FeBE7ufdYxW1/yzJO8drjRJ0hD6jPH/NPCKqpoBSPJ+4Crg1cBm4I+GK0+SdKj16fG/EPjRrO0fAy+qqscZ3WxFkrSA9Onx/znwpSS7F1N7E/Cp7svebwxWmSRpEH1m9Xygu2Xi6UCAX62qTd3Lbx2yOEnSoddr0faq2pTkfuDZAEleWFX3D1qZJGkQfRZpOyvJPYwu3Lqle/zs0IVJkobR58vdDwC/APxNVa1idEOVLwxalSRpMH2C/8fdGvqHJTmsqm4GXj5sWZKkofQZ4384yTLgVuCKJDtwdU5JWrD69PjPZnTrxd8C/hL4W0ZTOiVJC1Cf6ZyPdU+fAC4fthxJ0tD69PglSYuIwS9Jjdln8Ce5qXv8w/GVI0ka2v7G+Fck+UXgrCQbGS3X8A+q6quDViZJGsT+gv/3gEuBk4AP7/FaAa8ZqihJ0nD2GfxVdRVwVZLfraoPjLEmSdKA+q7OeRajG68ATFfV9cOWJUkaSp9F2v4AuJjR2vvfAC7u9kmSFqA+Sza8EXh5VT0BkORy4GvA+4YsTJI0jL7z+I+Z9fzoAeqQJI1Jnx7/HwBfS3Izoymdr8beviQtWH2+3P1Ukmng5xkF/29X1f8eujBJ0jD63npxG3DdwLVIksbAtXokqTEGvyQ1Zr/Bn+SwJHeNqxhJ0vD2G/zd3P07k7xwTPVIkgbW58vdFcDdSb4C7L4bF1V11mBVSZIG0yf4f3/wKiRJY9NnHv8tSV4EnFxV/yvJc4Alw5cmSRpCn0XafgW4Cvhv3a4Tgc/0OO4FSW5OsjXJ3Uku7vYfl+TGJPd0j8fOo35J0kHqM53zncDpwCMAVXUP8Lwex+0CLqmqnwV+AXhnkpcyurnLTVV1MnBTty1JGpM+wf/DqvrR7o0khzO6A9d+VdW23bdnrKpHga2M/rVwNnB597bLgXMOsmZJ0jykav8ZnuSPgIeBfw28C/g14BtV9e96nyRZCdwKvAy4v6qOmfXaQ1X1tOGeJOuAdQDLly8/dePGjX1P9xQ7HtzJ9sfndOiCtfxImmvzqqOXsGzZskmXMVYzMzO2uQHzafOaNWs2V9XUnvv7BP9hwEXA6xkt0vY54GN1oAOfPH4ZcAvwwaq6JsnDfYJ/tqmpqdq0aVOf0z3NR6+4lvVbei1JtGhccsqu5tq8Ye1SVq9ePekyxmp6eto2N2A+bU6y1+DvM6vnie7mK19mNMTzrYMI/SOAq4Erquqabvf2JCuqaluSFcCO3q2QJM1bn1k9bwT+FvhT4D8B9yb5pR7HBfg4sLWqPjzrpeuAC7rnFwDXHmzRkqS56zMesB5YU1X3AiR5MXAD8NkDHHc68HZgS5I7un3/FvgQcGWSi4D7gTfPoW5J0hz1Cf4du0O/8216DM9U1W2MvhPYm9f2OK8kaQD7DP4k53ZP707yP4ErGY3xvxm4fQy1SZIGsL8e/5tmPd8O/GL3/P8AXm0rSQvUPoO/qt4xzkIkSeNxwDH+JKsYXbi1cvb7XZZZkhamPl/ufobRtMz/ATwxaDWSpMH1Cf7/V1V/OnglkqSx6BP8f5Lk/cBfAT/cvXP3AmySpIWlT/CfwuhCrNfw5FBPdduSpAWmT/D/MvCPZi/NLElauPqsx38ncMzAdUiSxqRPj3858M0kt/PUMX6nc0rSAtQn+N8/eBWSpLHpsx7/LeMoRJI0Hn2u3H2UJ++x+1PAEcBjVfXcIQuTJA2jT4//qNnbSc4BXjlUQZKkYfWZ1fMUVfUZnMMvSQtWn6Gec2dtHgZM8eTQjyRpgekzq2f2uvy7gPuAswepRpI0uD5j/K7LL0mLyP5uvfh7+zmuquoDA9QjSRrY/nr8j+1l31LgIuCnAYNfkhag/d16cf3u50mOAi4G3gFsBNbv6zhJ0jPbfsf4kxwHvBt4K3A58IqqemgchUmShrG/Mf7/CJwLXAacUlUzY6tKkjSY/V3AdQnwfOB3gO8leaT7eTTJI+MpT5J0qO1vjP+gr+qVJD3zGe6S1BiDX5IaY/BLUmMMfklqjMEvSY3pszqn9Iy35YGdXHjpDZMuY6w2rF066RK0QNnjl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0ZLPiTfCLJjiR3zdp3XJIbk9zTPR471PklSXs3ZI9/A7B2j32XAjdV1cnATd22JGmMBgv+qroVeHCP3WczupMX3eM5Q51fkrR3qarhPjxZCVxfVS/rth+uqmNmvf5QVe11uCfJOmAdwPLly0/duHHjnGrY8eBOtj8+p0MXrOVHYpsbsOroJSxbtmzSZYzVzMyMbT4Ia9as2VxVU3vuf8Yu2VBVlzG67SNTU1O1evXqOX3OR6+4lvVbnrHNHMQlp+yyzQ3YsHYpc/29WKimp6dt8yEw7lk925OsAOged4z5/JLUvHEH/3XABd3zC4Brx3x+SWrekNM5PwV8EXhJku8muQj4EHBGknuAM7ptSdIYDTYoWlXn7+Ol1w51TknSgXnlriQ1xuCXpMYY/JLUmLYmPkuLiLeb1FzZ45ekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMq3NKWjBckfTQsMcvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGTCT4k6xN8q0k9ya5dBI1SFKrxh78SZYA/xn4JeClwPlJXjruOiSpVZPo8b8SuLeqvl1VPwI2AmdPoA5JalKqarwnTM4D1lbVv+m23w78i6r69T3etw5Y122+BPjWHE95PPD9OR67UNnmNtjmNsynzS+qqhP23Hn4/OqZk+xl39P+9qmqy4DL5n2yZFNVTc33cxYS29wG29yGIdo8iaGe7wIvmLV9EvC9CdQhSU2aRPDfDpycZFWSnwLeAlw3gTokqUljH+qpql1Jfh34HLAE+ERV3T3gKec9XLQA2eY22OY2HPI2j/3LXUnSZHnlriQ1xuCXpMYs6uBvbWmIJJ9IsiPJXZOuZRySvCDJzUm2Jrk7ycWTrmloSZ6d5CtJ7uza/PuTrmlckixJ8rUk10+6lnFIcl+SLUnuSLLpkH72Yh3j75aG+BvgDEZTSG8Hzq+qb0y0sAEleTUwA/z3qnrZpOsZWpIVwIqq+mqSo4DNwDmL/P9xgKVVNZPkCOA24OKq+tKESxtckncDU8Bzq+rMSdcztCT3AVNVdcgvWFvMPf7mloaoqluBByddx7hU1baq+mr3/FFgK3DiZKsaVo3MdJtHdD+Ls/c2S5KTgDcCH5t0LYvBYg7+E4G/n7X9XRZ5KLQsyUrg54AvT7iUwXVDHncAO4Abq2rRtxn4CPBe4IkJ1zFOBfxVks3dEjaHzGIO/l5LQ2jhS7IMuBr4zap6ZNL1DK2qflJVL2d01fsrkyzqYb0kZwI7qmrzpGsZs9Or6hWMVjJ+ZzeUe0gs5uB3aYgGdOPcVwNXVNU1k65nnKrqYWAaWDvZSgZ3OnBWN+a9EXhNkk9OtqThVdX3uscdwF8wGr4+JBZz8Ls0xCLXfdH5cWBrVX140vWMQ5ITkhzTPT8SeB3wzYkWNbCqel9VnVRVKxn9Hn++qt424bIGlWRpN2GBJEuB1wOHbLbeog3+qtoF7F4aYitw5cBLQ0xckk8BXwRekuS7SS6adE0DOx14O6Me4B3dzxsmXdTAVgA3J/k6o87NjVXVxPTGxiwHbktyJ/AV4Iaq+stD9eGLdjqnJGnvFm2PX5K0dwa/JDXG4Jekxhj8ktQYg1+SGmPwq1lJ/jjJb87a/lySj83aXt8tDHYwn/nvk7yne35hkufPeu2+JMcfgtKleTH41bK/Bl4FkOQw4Hjgn856/VXAF+bx+RcCzz/Qm6RxM/jVsi/QBT+jwL8LeDTJsUmeBfwsQJJbuoWyPtctBU2SX0lye7cu/tVJnjP7g5Ocx2gJ4Su6C8uO7F56V5Kvduus/8w4GintyeBXs7q1UHYleSGjvwC+yGh1z9MYhfZW4I+B86rqVOATwAe7w6+pqp+vqn/eve+iPT77KmAT8NaqenlVPd699P1u4a3/Arxn0AZK+3D4pAuQJmx3r/9VwIcZLd39KmAn8ACjNVJuHC0LxBJgW3fcy5L8B+AYYBmjpUH62L2Q3Gbg3PmXLx08g1+t2z3OfwqjoZ6/By4BHgE+D5xYVaft5bgNjO72dWeSC4HVPc/3w+7xJ/j7pwlxqEet+wJwJvBgt879g4x68acBnwZOSHIajJaATrL7y9+jgG3dstBv3cdnP9q9T3pGMfjVui2MZvN8aY99O7t10M8D/rBbJfEOnvwy+HcZfR9wI/teFnkD8F/3+HJXmjhX55Skxtjjl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMf8f1xdpTHHr+cEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data = results.variables.wealth_agent\n", + "data.hist(bins=range(data.wealth.max()+1))\n", + "\n", + "plt.title('')\n", + "plt.xlabel('Wealth')\n", + "plt.ylabel('Number of agents')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "What we get is a Boltzmann distribution. For those interested to understand this result, you can read more about it [here](http://www.phys.ufl.edu/~meisel/Boltzmann.pdf)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "Project Mesa Team (2016). Introductory Tutorial (Revision 25205080). Retrieved from https://mesa.readthedocs.io/en/master/tutorials/intro_tutorial.html" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}