soil/docs/tutorial/soil_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-19T12:41:48.007238Z",
     "start_time": "2017-10-19T14:41:47.980725+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "# Soil Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-02T16:44:14.120953Z",
     "start_time": "2017-07-02T18:44:14.117152+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "This notebook is an introduction to the soil agent-based social network simulation framework.\n",
    "Soil is built on top of [Mesa](https://mesa.readthedocs.io/), a general simulation library, and it introduces features specifically tailored to social simulations.\n",
    "\n",
    "It will focus on a specific use case: studying the propagation of disinformation through TV and social networks.\n",
    "In the following sections we will:\n",
    "\n",
    "* Cover the basics of mesa and Soil (environments, agents, etc.)\n",
    "* Simulate a basic scenario with a single agent\n",
    "* Add more complexity to our scenario\n",
    "* Run simulations using different configurations\n",
    "* Analyze the results of each simulation\n",
    "\n",
    "The simulations in this tutorial will be kept simple, for the sake of clarity.\n",
    "However, they provide all the building blocks necessary to model, run and analyse more complex scenarios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T13:38:48.052876Z",
     "start_time": "2017-07-03T15:38:48.044762+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "But before that, let's import the soil module and networkx."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-03T10:58:13.451481Z",
     "start_time": "2017-11-03T11:58:12.643469+01:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "from soil import *\n",
    "import soil\n",
    "import networkx as nx\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T13:41:19.788717Z",
     "start_time": "2017-07-03T15:41:19.785448+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Basic concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Simulations are based on the concept of a **model** (or environment).\n",
    "A model represents the world where the simulation will be run.\n",
    "It usually contains:\n",
    "\n",
    "  * All the simulation parameters (given in the constructor)\n",
    "  * A reference to every agent in the simulation\n",
    "  * A data collector, which will capture any relevant information for agents (agent reporters) or the model itself (model reporters)\n",
    "  * A scheduler (`soil.time.Scheduler` or `mesa.time.BaseScheduler`), which is responsible of coordinating the activation of agents at each simulation step\n",
    "  * A grid or space where agents can move (optional)\n",
    "    \n",
    "Soil introduces the `soil.NetworkEnvironment` model class.\n",
    "This type of environment contain a network topology (accessible through through `self.G`).\n",
    "The topology can be manually provided to the environment, or it can be randomly generated through multiple network parameters.\n",
    "      \n",
    "**Agents** are programmed with their individual behaviors, and they can communicate with the environment and with other agents. There are several types of agents, depending on their behavior and their capabilities. Some examples of built-in types of agents are:\n",
    "    - Network agents, which are linked to a node in the topology. They have additional methods to access their neighbors.\n",
    "    - FSM (Finite state machine) agents. Their behavior is defined in terms of states, and an agent will move from one state to another.\n",
    "    - Evented agents, an actor-based model of agents, which can communicate with one another through message passing.\n",
    "    - For convenience, a general `soil.Agent` class is provided, which inherits from Network, FSM and Evented at the same time.\n",
    "\n",
    "Soil provides several abstractions over events to make developing agents easier.\n",
    "This means you can use events (timeouts, delays) in soil.\n",
    "But, for the most part, we will assume your models will be step-based."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-02T15:55:12.933978Z",
     "start_time": "2017-07-02T17:55:12.930860+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Modeling behaviour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T13:49:31.269687Z",
     "start_time": "2017-07-03T15:49:31.257850+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Our first step will be to model how every person in the social network reacts to hearing a piece of disinformation (news).\n",
    "We will follow a very simple model based on a finite state machine.\n",
    "\n",
    "A person may be in one of two states: **neutral** (the default state) and **infected**.\n",
    "A neutral person may hear about a piece of disinformation either on the TV (with probability **prob_tv_spread**) or through their friends.\n",
    "Once a person has heard the news, they will spread it to their friends (with a probability **prob_neighbor_spread**).\n",
    "Some users do not have a TV, so they will only be infected by their friends.\n",
    "\n",
    "The spreading probabilities will change over time due to different factors.\n",
    "We will represent this variance using an additional agent which will not be a part of the social network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A simple model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleModel(soil.Environment):\n",
    "    max_steps_neutral = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Modelling Agents\n",
    "\n",
    "The following sections will cover the basics of developing agents in SOIL.\n",
    "\n",
    "For more advanced patterns, please check the **examples** folder in the repository."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### Basic agents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T14:03:07.171127Z",
     "start_time": "2017-07-03T16:03:07.165779+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "The most basic agent in Soil is ``soil.BaseAgent``.\n",
    "These agents implement their behavior by overriding the `step` method, which will be run in every simulation step.\n",
    "Only one agent will be running at any given time, and it will be doing so until the `step` function returns.\n",
    "\n",
    "Agents can access their environment through their ``self.model`` attribute.\n",
    "This is most commonly used to get access to the environment parameters and methods.\n",
    "Here is a simple example of an agent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T14:03:07.171127Z",
     "start_time": "2017-07-03T16:03:07.165779+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "class ExampleAgent(BaseAgent):\n",
    "    def init(self):\n",
    "        self.is_infected = False\n",
    "        self.steps_neutral = 0\n",
    "    \n",
    "    def step(self):\n",
    "        # Implement agent logic\n",
    "        if self.is_infected:\n",
    "            ... # Do something, like infecting other agents\n",
    "            return self.die(\"No need to do anything else\") # Stop forever\n",
    "        else:\n",
    "            ... # Do something\n",
    "            self.steps_neutral += 1\n",
    "            if self.steps_neutral > self.model.max_steps_neutral:\n",
    "                self.is_infected = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T14:03:07.171127Z",
     "start_time": "2017-07-03T16:03:07.165779+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Any kind of agent behavior can be implemented with this `step` function.\n",
    "dead, it has two main drawbacks: 1) complex behaviors can get difficult both write and understand; 2) these behaviors are not composable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how the agent works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent 0 is alive and infected\n",
      "Agent 0 is alive and infected\n",
      "Agent 0 is alive and infected\n",
      "Agent 0 is alive and not infected\n",
      "Agent 0 is dead and not infected\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/j/.cache/pypoetry/virtualenvs/soil-cCX5yKRx-py3.10/lib/python3.10/site-packages/mesa/time.py:82: FutureWarning: The AgentSet is experimental. It may be changed or removed in any and all future releases, including patch releases.\n",
      "We would love to hear what you think about this new feature. If you have any thoughts, share them with us here: https://github.com/projectmesa/mesa/discussions/1919\n",
      "  self._agents: AgentSet = AgentSet(agents, model)\n"
     ]
    }
   ],
   "source": [
    "model = SimpleModel()\n",
    "num_steps = model.max_steps_neutral+2\n",
    "a = ExampleAgent(unique_id=0, model=model)\n",
    "for i in range(num_steps):\n",
    "    ret = a.step()\n",
    "    print(f\"Agent {a.unique_id} is {'alive' if a.alive else 'dead'} and {'infected' if not a.is_infected else 'not infected'}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent 0 is alive and infected @ 1\n",
      "Agent 0 is alive and infected @ 2\n",
      "Agent 0 is alive and infected @ 3\n",
      "Agent 0 is alive and not infected @ 4\n",
      "Agent 0 is dead and not infected @ inf\n"
     ]
    }
   ],
   "source": [
    "model = SimpleModel()\n",
    "a = model.add_agent(ExampleAgent)\n",
    "for i in range(num_steps):\n",
    "    model.step()\n",
    "    print(f\"Agent {a.unique_id} is {'alive' if a.alive else 'dead'} and {'infected' if not a.is_infected else 'not infected'} @ {model.now}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T14:03:07.171127Z",
     "start_time": "2017-07-03T16:03:07.165779+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### FSM agents\n",
    "\n",
    "One way to solve both issues is to model agents as **[Finite-state Machines](https://en.wikipedia.org/wiki/Finite-state_machine)** (FSM, for short).\n",
    "FSM define a series of possible states for the agent, and changes between these states.\n",
    "These states can be modelled and extended independently.\n",
    "\n",
    "This is modelled in Soil through the `soil.FSM` class.\n",
    "Agents that inherit from ``soil.FSM`` do not need to specify a ``step`` method.\n",
    "Instead, we describe each finite state with a function.\n",
    "To change to another state, a function may return the new state, or the ``id`` of a state.\n",
    "If no state is returned, the state remains unchanged.\n",
    "\n",
    "The current state of the agent can be checked with ``agent.state_id``.\n",
    "That state id can be used to look for other agents in that specific state.\n",
    "\n",
    "Our previous example could be expressed like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T14:03:07.171127Z",
     "start_time": "2017-07-03T16:03:07.165779+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "class FSMExample(FSM):\n",
    "\n",
    "    def init(self):\n",
    "        self.steps_neutral = 0\n",
    "    \n",
    "    @state(default=True)\n",
    "    def neutral(self):\n",
    "        ... # Do something\n",
    "        self.steps_neutral += 1\n",
    "        if self.steps_neutral > self.model.max_steps_neutral:\n",
    "            return self.infected  # Change state\n",
    "\n",
    "    @state\n",
    "    def infected(self):\n",
    "        ... # Do something\n",
    "        return self.die(\"No need to do anything else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent 0 is alive and neutral @ 1\n",
      "Agent 0 is alive and neutral @ 2\n",
      "Agent 0 is alive and neutral @ 3\n",
      "Agent 0 is alive and infected @ 4\n",
      "Agent 0 is dead and dead @ inf\n"
     ]
    }
   ],
   "source": [
    "model = SimpleModel()\n",
    "a = model.add_agent(FSMExample)\n",
    "for i in range(num_steps):\n",
    "    ret = model.step()\n",
    "    print(f\"Agent {a.unique_id} is {'alive' if a.alive else 'dead'} and {a.state_id} @ {model.now}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### Telling the scheduler when to wake up an agent\n",
    "\n",
    "By default, every agent will be called in every simulation step, and the time elapsed between two steps is controlled by the `default_interval` attribute in the environment.\n",
    "\n",
    "But agents may signal the scheduler how long to wait before calling them again by returning (or `yield`ing) a value other than `None`.\n",
    "This is especially useful when an agent is going to be dormant for a long time.\n",
    "There are two convenience methods to calculate the value to return: `Agent.delay`, which takes a time delay; and `Agent.at`, which takes an absolute time at which the agent should be awaken.\n",
    "A return (or `yield`) value of `None` will default to a wait of 1 unit of time.\n",
    "\n",
    "When an `FSM` agent returns, it may signal two things: how long to wait, and a state to transition to.\n",
    "This can be done by using the `delay` and `at` methods of each state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FSMExampleDelayed(FSMExample):\n",
    "    \n",
    "    @state(default=True)\n",
    "    def neutral(self):\n",
    "        return self.infected.delay(self.model.max_steps_neutral)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent 0 is alive and infected @ 3.0\n",
      "Agent 0 is dead and dead @ inf\n",
      "Agent 0 is dead and dead @ inf\n",
      "Agent 0 is dead and dead @ inf\n",
      "Agent 0 is dead and dead @ inf\n"
     ]
    }
   ],
   "source": [
    "model = SimpleModel()\n",
    "a = model.add_agent(FSMExampleDelayed)\n",
    "for i in range(num_steps):\n",
    "    ret = model.step()\n",
    "    print(f\"Agent {a.unique_id} is {'alive' if a.alive else 'dead'} and {a.state_id} @ {model.now}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-02T12:22:53.931963Z",
     "start_time": "2017-07-02T14:22:53.928340+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Environment agents"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "In our simulation, we need a way to model how TV broadcasts news, and those that have a TV are susceptible to it.\n",
    "We will only model one very viral TV broadcast, which we will call an `event`, which has a high chance of infecting users with a TV.\n",
    "\n",
    "\n",
    "There are several ways to model this behavior.\n",
    "We will do it with an Environment Agent.\n",
    "Environment agents are regular agents that interact with the environment but are invisible to other agents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-03T10:58:17.653736Z",
     "start_time": "2017-11-03T11:58:17.612944+01:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "class EventGenerator(BaseAgent):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "    def step(self):\n",
    "        # Do nothing until the time of the event\n",
    "        yield self.at(self.model.event_time)\n",
    "        self.debug(\"TV event happened\")\n",
    "        self.model.prob_tv_spread = 0.5\n",
    "        self.model.prob_neighbor_spread = min(self.model.prob_neighbor_spread*2, 1)\n",
    "        yield self.delay()\n",
    "        self.model.prob_tv_spread = 0\n",
    "\n",
    "        while self.alive:\n",
    "            self.model.prob_neighbor_spread = self.model.prob_neighbor_spread * self.model.neighbor_factor\n",
    "            if self.model.prob_neighbor_spread < 0.01:\n",
    "                return self.die(\"neighbors can no longer spread the rumour\")\n",
    "            yield self.delay()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Environment (Model)\n",
    "\n",
    "Let's define a environment model to test our event generator agent.\n",
    "This environment will have a single agent (the event generator).\n",
    "We will also tell the environment to save the value of `prob_tv_spread` after every step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "class NewsEnvSimple(NetworkEnvironment):\n",
    "    \n",
    "    # Here we set the default parameters for our model\n",
    "    # We will be able to override them on a per-simulation basis\n",
    "    prob_tv_spread = 0.1\n",
    "    prob_neighbor_spread = 0.1\n",
    "    event_time = 10\n",
    "    neighbor_factor = 0.9\n",
    "\n",
    "    \n",
    "    # This function initializes the model. It is run right at the end of the `__init__` function.\n",
    "    def init(self):\n",
    "        self.add_model_reporter(\"prob_tv_spread\") # save prob_tv_spread at every step\n",
    "        self.add_agent(EventGenerator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Once the environment has been defined, we can quickly run our simulation through the `run` method on NewsEnv:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "86199270e7f74321bfc4481c95942d67",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "NewsEnvSimple:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>step</th>\n",
       "      <th>agent_count</th>\n",
       "      <th>prob_tv_spread</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>time</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.0</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10.0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11.0</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12.0</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13.0</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14.0</th>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      step  agent_count  prob_tv_spread\n",
       "time                                   \n",
       "0.0      0            1             0.1\n",
       "10.0     1            1             0.1\n",
       "11.0     2            1             0.5\n",
       "12.0     3            1             0.0\n",
       "13.0     4            1             0.0\n",
       "14.0     5            1             0.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "its = NewsEnvSimple.run(iterations=1, max_time=14)\n",
    "its[0].model_df()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "As we can see, the event occurred right after `t=10`, so by `t=11` the value of `prob_tv_spread` was already set to `0.5`.\n",
    "\n",
    "You may notice nothing happened between `t=0` and `t=1`.\n",
    "That is because there aren't any other agents in the simulation, and our event generator explicitly waited until `t=10`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also get more information if we run the simulation with logging set to DEBUG:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "468d9985226a4f0cac12f62e566bce1b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "NewsEnvSimple:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "NewsEnvSimple.run(iterations=1, max_time=14);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Network agents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T14:03:07.171127Z",
     "start_time": "2017-07-03T16:03:07.165779+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "In our disinformation scenario, we will model our agents as a FSM with two states: ``neutral`` (default) and ``infected``.\n",
    "\n",
    "Here's the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-03T10:58:16.051690Z",
     "start_time": "2017-11-03T11:58:16.006044+01:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "class NewsSpread(Agent):\n",
    "    has_tv = False\n",
    "    infected_by_friends = False\n",
    "    \n",
    "    # The state decorator is used to define the states of the agent\n",
    "    @state(default=True)\n",
    "    def neutral(self):\n",
    "        # The agent might have been infected by their infected friends since the last time they were checked\n",
    "        if self.infected_by_friends:\n",
    "            # Automatically transition to the infected state\n",
    "            return self.infected\n",
    "        # If the agent has a TV, they might be infected by the evenn\n",
    "        if self.has_tv:\n",
    "            if self.prob(self.model.prob_tv_spread):\n",
    "                self.info(\"INFECTED\")\n",
    "                return self.infected\n",
    "            \n",
    "    @state\n",
    "    def infected(self):\n",
    "        for neighbor in self.iter_neighbors(state_id=self.neutral.id):\n",
    "            if self.prob(self.model.prob_neighbor_spread):\n",
    "                neighbor.infected_by_friends = True\n",
    "        return self.delay(7) # Wait for 7 days before trying to infect their friends again"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "We can check that our states are well defined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dead', 'neutral', 'infected']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NewsSpread.states()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Environment (Model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Let's modify our simple simulation.\n",
    "We will add a network of agents of type NewsSpread.\n",
    "\n",
    "Only one agent (0) will have a TV (in blue)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "cell_style": "split",
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def generate_simple():\n",
    "    G = nx.Graph()\n",
    "    G.add_edge(0, 1)\n",
    "    G.add_edge(0, 2)\n",
    "    G.add_edge(2, 3)\n",
    "    G.add_node(4)\n",
    "    return G\n",
    "\n",
    "G = generate_simple()\n",
    "pos = nx.spring_layout(G)\n",
    "nx.draw_networkx(G, pos, node_color='red')\n",
    "nx.draw_networkx(G, pos, nodelist=[0], node_color='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "class NewsEnvNetwork(Environment):\n",
    "    prob_tv_spread = 0\n",
    "    prob_neighbor_spread = 0.1\n",
    "    event_time = 10\n",
    "    neighbor_factor = 0.9\n",
    "\n",
    "    def init(self):\n",
    "        self.add_agent(EventGenerator)\n",
    "        self.G = generate_simple()\n",
    "        self.populate_network(NewsSpread)\n",
    "        self.agent(node_id=0).has_tv = True\n",
    "        self.add_model_reporter('prob_tv_spread')\n",
    "        self.add_model_reporter('prob_neighbor_spread')\n",
    "        self.add_agent_reporter('state_id', lambda a: getattr(a, \"state_id\", None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "26d045b0cd18418ab14507ac59f5a236",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "NewsEnvNetwork:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "its = NewsEnvNetwork.run(iterations=3, max_time=14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>step</th>\n",
       "      <th>agent_count</th>\n",
       "      <th>prob_tv_spread</th>\n",
       "      <th>prob_neighbor_spread</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>time</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.0</th>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.0</th>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3.0</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4.0</th>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      step  agent_count  prob_tv_spread  prob_neighbor_spread\n",
       "time                                                         \n",
       "0.0      0            6             0.0                   0.1\n",
       "1.0      1            6             0.0                   0.1\n",
       "2.0      2            6             0.0                   0.1\n",
       "3.0      3            6             0.0                   0.1\n",
       "4.0      4            6             0.0                   0.1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "it = []\n",
    "for i in range(3):\n",
    "    env = NewsEnvNetwork(seed=i+5)\n",
    "    for i in range(50):\n",
    "        env.step()\n",
    "    it.append(env)\n",
    "it[0].model_df().head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "90f0eab223de4c0cb834633fe037ae2f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "NewsEnvNetwork:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[INFO ][17:23:10] [@10.0]\tNewsSpread(1): INFECTED\n",
      "[INFO ][17:23:10] [@11.0]\tNewsSpread(1): INFECTED\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "it = NewsEnvNetwork.run(iterations=3, seed=4, max_time=30, level=logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "In this case, notice that the inclusion of other agents (which run every step) means that the simulation did not skip to `t=10`.\n",
    "\n",
    "Now, let's look at the state of our agents in every step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from soil import analysis\n",
    "for res in it:\n",
    "    analysis.plot(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "hideCode": false,
    "hidePrompt": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "## Running in more scenarios\n",
    "\n",
    "In real life, you probably want to run several simulations, varying some of the parameters so that you can compare and answer your research questions.\n",
    "\n",
    "For instance:\n",
    "    \n",
    "* Does the outcome depend on the structure of our network? We will use different generation algorithms to compare them (Barabasi-Albert and Erdos-Renyi)\n",
    "* How does neighbor spreading probability affect my simulation? We will try probability values in the range of [0, 0.4], in intervals of 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "class NewsEnvComplete(Environment):\n",
    "    prob_tv = 0.1\n",
    "    prob_tv_spread = 0\n",
    "    prob_neighbor_spread = 0.1\n",
    "    event_time = 10\n",
    "    neighbor_factor = 0.5\n",
    "    generator = \"erdos_renyi_graph\"\n",
    "    n = 100\n",
    "\n",
    "    def init(self):\n",
    "        self.add_agent(EventGenerator)\n",
    "        opts = {\"n\": self.n}\n",
    "        if self.generator == \"erdos_renyi_graph\":\n",
    "            opts[\"p\"] = 0.05\n",
    "        elif self.generator == \"barabasi_albert_graph\":\n",
    "            opts[\"m\"] = 2\n",
    "        self.create_network(generator=self.generator, **opts)\n",
    "\n",
    "        self.populate_network([NewsSpread,\n",
    "                               NewsSpread.w(has_tv=True)],\n",
    "                               [1-self.prob_tv, self.prob_tv])\n",
    "        self.add_model_reporter('prob_tv_spread')\n",
    "        self.add_model_reporter('prob_neighbor_spread')\n",
    "        self.add_agent_reporter('state_id', lambda a: getattr(a, \"state_id\", None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(its.values())[0][3].count_agents(state_id='infected')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "522fa16a8a52488781e69f025ec51cc1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0\n",
      "  generator = erdos_renyi_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a46911e00cf04c7d9504c70d3105bfc9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0\n",
      "  generator = barabasi_albert_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f3202fff4879428b8505f4fd7c7605e1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0.25\n",
      "  generator = erdos_renyi_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6e3bee309cd043b19b4ea90f1ea3e039",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0.25\n",
      "  generator = barabasi_albert_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7369e8dc45d545899c07a0e1de2cec52",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0.5\n",
      "  generator = erdos_renyi_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a1cac9f81c46470fb9b20eab88bfe0da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0.5\n",
      "  generator = barabasi_albert_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f48b611e76bb4363a14182dd5fea6059",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0.75\n",
      "  generator = erdos_renyi_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5d8fffaacc084c0b9b14de13e0c968fb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 0.75\n",
      "  generator = barabasi_albert_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d50a638f8b3b45909d9e7b56418abcc5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 1.0\n",
      "  generator = erdos_renyi_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f494cf391b354761b23c8c772d330422",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/1 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  N = 100\n",
      "  prob_neighbor_spread = 1.0\n",
      "  generator = barabasi_albert_graph\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Ns = [100]\n",
    "probabilities = [0, 0.25, 0.5, 0.75, 1.0]\n",
    "generators = [\"erdos_renyi_graph\", \"barabasi_albert_graph\"]\n",
    "\n",
    "its = {}\n",
    "for N in Ns:\n",
    "    for prob_neighbor_spread in probabilities:\n",
    "        for generator in generators:\n",
    "            params = dict(N=N, prob_neighbor_spread=prob_neighbor_spread, generator=generator)\n",
    "            env = NewsEnvComplete.run(name=f\"newspread\",\n",
    "                         iterations=5,\n",
    "                         max_time=30,\n",
    "                         level=logging.WARNING,\n",
    "                         parameters=params)\n",
    "            its[(N, prob_neighbor_spread, generator)] = env\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(its)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Storing results and analyzing them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time, we set `dump=True` because we want to store our results to a database, so that we can later analyze them.\n",
    "\n",
    "But since we do not care about existing results in the database, we will also set`overwrite=True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5004870a00c48de8fd16e47b91e47ec",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "newspread:   0%|          | 0/10 [00:00<?, ?configuration/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = erdos_renyi_graph\n",
      "  prob_neighbor_spread = 0\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = erdos_renyi_graph\n",
      "  prob_neighbor_spread = 0.25\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = erdos_renyi_graph\n",
      "  prob_neighbor_spread = 0.5\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = erdos_renyi_graph\n",
      "  prob_neighbor_spread = 0.75\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = erdos_renyi_graph\n",
      "  prob_neighbor_spread = 1.0\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = barabasi_albert_graph\n",
      "  prob_neighbor_spread = 0\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = barabasi_albert_graph\n",
      "  prob_neighbor_spread = 0.25\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = barabasi_albert_graph\n",
      "  prob_neighbor_spread = 0.5\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = barabasi_albert_graph\n",
      "  prob_neighbor_spread = 0.75\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Running for parameters: \n",
      "  n = 100\n",
      "  generator = barabasi_albert_graph\n",
      "  prob_neighbor_spread = 1.0\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "it = NewsEnvComplete.run(name=f\"newspread\",\n",
    "                         iterations=5,\n",
    "                         max_time=30,\n",
    "                         level='WARNING',\n",
    "                         dump=True,\n",
    "                         overwrite=True,\n",
    "                         matrix=dict(n=[N],\n",
    "                                     generator=generators,\n",
    "                                     prob_neighbor_spread=probabilities))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "DEFAULT_ITERATIONS = 5\n",
    "assert len(it) == len(probabilities) * len(generators) * DEFAULT_ITERATIONS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T11:05:18.043194Z",
     "start_time": "2017-07-03T13:05:18.034699+02:00"
    },
    "cell_style": "center",
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "The results are conveniently stored in sqlite (history of agent and environment state) and the configuration is saved in a YAML file.\n",
    "\n",
    "You can also export the results to GEXF format (dynamic network) and CSV using .`run(dump=['gexf', 'csv'])` or the command line flags `--graph --csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-11-01T14:05:56.404540Z",
     "start_time": "2017-11-01T15:05:56.122876+01:00"
    },
    "cell_style": "split",
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[01;34msoil_output\u001b[0m\n",
      "└── \u001b[01;34mnewspread\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712844336.8642576.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712844450.0526526.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712846070.381033.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712846089.2092683.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712846145.296178.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712846219.0644977.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712846305.368385.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712846671.6566656.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712849017.0672383.dumped.yml\u001b[0m\n",
      "    ├── \u001b[00mnewspread_1712849444.2514122.dumped.yml\u001b[0m\n",
      "    └── \u001b[00mnewspread.sqlite\u001b[0m\n",
      "\n",
      "1 directory, 11 files\n",
      "4,0K\tsoil_output/newspread/.ipynb_checkpoints\n",
      "21M\tsoil_output/newspread\n"
     ]
    }
   ],
   "source": [
    "!tree soil_output\n",
    "!du -xh soil_output/*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-02T10:40:14.384177Z",
     "start_time": "2017-07-02T12:40:14.381885+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Analysing the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### Loading data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Once the simulations are over, we can use soil to analyse the results.\n",
    "\n",
    "There are two main ways: directly using the iterations returned by the `run` method, or loading up data from the results database.\n",
    "This is particularly useful to store data between sessions, and to accumulate results over multiple runs.\n",
    "\n",
    "The mainThe main method to load data from the database is `read_sql`, which can be used in two ways:\n",
    "\n",
    "* `analysis.read_sql(<sqlite_file>)` to load all the results from a sqlite database . e.g. `read_sql('my_simulation/file.db.sqlite')`\n",
    "* `analysis.read_sql(name=<simulation name>)` will look for the default path for a simulation named `<simulation name>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result in both cases is a named tuple with four dataframes:\n",
    "\n",
    "* `configuration`, which contains configuration parameters per simulation\n",
    "* `parameters`, which shows the parameters used **in every iteration** of every simulation\n",
    "* `env`, with the data collected from the model in each iteration (as specified in `model_reporters`)\n",
    "* `agents`, like `env`, but for `agent_reporters`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-03T14:44:30.978223Z",
     "start_time": "2017-07-03T16:44:30.971952+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Let's see it in action by loading the stored results into a pandas dataframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-19T15:57:44.101253Z",
     "start_time": "2017-10-19T17:57:44.039710+02:00"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "res = analysis.read_sql(name=\"newspread\", include_agents=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting data\n",
    "\n",
    "Once we have loaded the results from the file, we can use them just like any other dataframe.\n",
    "\n",
    "Here is an example of plotting the ratio of infected users in each of our simulations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHHCAYAAABtF1i4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC/rUlEQVR4nOzdd1xT5/7A8U9ISBhhi4II4sCNCxe0dVQsjvJTa+1Vb0VbFxZ3bUW7rFixVXG0Wruuq9bbal23al11XBdeZ22luEBaFVBkyCbJ+f0ROTUyowzH83698tJz8j3P+Z4QyJNnHYUkSRKCIAiCIAjVxKK6ExAEQRAE4ekmKiOCIAiCIFQrURkRBEEQBKFaicqIIAiCIAjVSlRGBEEQBEGoVqIyIgiCIAhCtRKVEUEQBEEQqpWojAiCIAiCUK1EZUQQBEEQhGolKiOCYCZvb29efPHFCitv//79KBQKNmzYUGbs8OHD8fb2NtmnUCiYOXOmvL1y5UoUCgXx8fEVlmNJkpKSePnll3FxcUGhULBo0aJKP2dVGz58OFqttrrTMFtmZiYjR47Ezc0NhULBpEmTiI+PR6FQsHLlyupO76Hc/54XHn+iMvIUK/zQUigUHDp0qMjzkiTh6emJQqGo0A9foeotW7asUj6AJk+ezM6dO5k+fTpr1qyhZ8+eFX4O4cHMmTOHlStXMnbsWNasWcPQoUOrOyWzbN++XVQ4niKq6k5AqH5WVlZ89913PPvssyb7Dxw4wF9//YVGo6mmzIT7ffXVVxgMhlJjhg4dyqBBg0x+bsuWLaNGjRoMHz68QvP55Zdf6Nu3L1OnTq3QcoWH98svv9CpUyc++OADeZ8kSeTk5GBpaVmNmZXP9u3bWbp0abEVkpycHFQq8fH1JBEtIwK9e/dm/fr16HQ6k/3fffcdfn5+uLm5VVNmVSMrK6u6Uyg3S0vLMiuHSqUSKysrFApFpeeTnJyMo6NjhZWXm5tbZmVLKJ/ifjYKhQIrKyuUSmWV51ORv2dWVlaiMvKEEZURgcGDB5OSksLu3bvlffn5+WzYsIEhQ4YUe4zBYGDRokU0b94cKysratWqxZgxY0hNTTWJ27JlC3369KF27dpoNBoaNGhAREQEer3eJK5r1660aNGC8+fP061bN2xsbPDw8OCTTz4p1zUoFArGjRvH2rVrady4MVZWVvj5+XHw4EGTuJkzZ6JQKDh//jxDhgzByclJbhHS6XRERETQoEEDNBoN3t7ezJgxg7y8vGLPuWvXLlq3bo2VlRXNmjVj48aNJs/fvn2bqVOn4uvri1arxd7enl69enH27Nliy9Pr9cyYMQM3NzdsbW35v//7P/7880+TmOLGjNzv/jEj3t7e/P777xw4cEDuluvatStXrlxBoVCwcOHCImUcOXIEhULBunXrSj2HJEksXbpULrfQlStXGDhwIM7OztjY2NCpUye2bdtmUkbhWJl///vfvPvuu3h4eGBjY0NGRkaJ11bR7zuA6OhoevfujZOTE7a2trRs2ZLFixcXibt27Rr9+vVDq9Xi6urK1KlTiy2vODt27KBLly7Y2dlhb29P+/bt+e6770xi1q9fj5+fH9bW1tSoUYNXX32Va9eumcQUjl8pLZfC1zUuLo5t27bJP5v4+PgSx4ysX7+eZs2aYWVlRYsWLdi0aVOR91phufv37zc5trgyC/O8fPkyvXv3xs7Ojn/+858A/Pe//2XgwIF4eXmh0Wjw9PRk8uTJ5OTkmBy/dOlSADn/e99fxY0ZOX36NL169cLe3h6tVkv37t05duyYSUzh+/bw4cNMmTIFV1dXbG1t6d+/Pzdv3iz+hydUCVG1FPD29sbf359169bRq1cvwPjHMz09nUGDBrFkyZIix4wZM4aVK1fy2muvMWHCBOLi4vjss884ffo0hw8flpuBV65ciVarZcqUKWi1Wn755Rfef/99MjIymDdvnkmZqamp9OzZk5deeolXXnmFDRs2MG3aNHx9feW8SnPgwAG+//57JkyYgEajYdmyZfTs2ZPjx4/TokULk9iBAwfi4+PDnDlzkCQJgJEjR7Jq1Spefvll3nzzTaKjo4mMjCQmJoZNmzaZHH/x4kX+8Y9/EBoayrBhw1ixYgUDBw7k559/pkePHoDxA3nz5s0MHDiQevXqkZSUxBdffEGXLl04f/48tWvXNinzo48+QqFQMG3aNJKTk1m0aBGBgYGcOXMGa2vrMq+/JIsWLWL8+PFotVreeecdAGrVqkX9+vV55plnWLt2LZMnTzY5Zu3atdjZ2dG3b99iy+zcubM8DqFHjx6EhITIzyUlJREQEEB2djYTJkzAxcWFVatW8X//939s2LCB/v37m5QVERGBWq1m6tSp5OXloVarS7yWin7f7d69mxdffBF3d3cmTpyIm5sbMTEx/PTTT0ycOFGO0+v1BAUF0bFjR+bPn8+ePXtYsGABDRo0YOzYsaW+/itXruT111+nefPmTJ8+HUdHR06fPs3PP/8sV/YLr6l9+/ZERkaSlJTE4sWLOXz4MKdPnzZp4Sgrl6ZNm7JmzRomT55MnTp1ePPNNwFwdXUt9gN327Zt/OMf/8DX15fIyEhSU1MZMWIEHh4epV5XWXQ6HUFBQTz77LPMnz8fGxsbwFjxyc7OZuzYsbi4uHD8+HE+/fRT/vrrL9avXw8Yf87Xr19n9+7drFmzpsxz/f777zz33HPY29vz9ttvY2lpyRdffEHXrl05cOAAHTt2NIkfP348Tk5OfPDBB8THx7No0SLGjRvH999//1DXLDwESXhqrVixQgKk//3vf9Jnn30m2dnZSdnZ2ZIkSdLAgQOlbt26SZIkSXXr1pX69OkjH/ff//5XAqS1a9ealPfzzz8X2V9Y3r3GjBkj2djYSLm5ufK+Ll26SIC0evVqeV9eXp7k5uYmDRgwoMxrASRAOnHihLzv6tWrkpWVldS/f3953wcffCAB0uDBg02OP3PmjARII0eONNk/depUCZB++eUXeV/dunUlQPrxxx/lfenp6ZK7u7vUpk0beV9ubq6k1+tNyouLi5M0Go00a9Ysed++ffskQPLw8JAyMjLk/T/88IMESIsXL5b3DRs2TKpbt26Ra//ggw/k7cKfa1xcnLyvefPmUpcuXaT7ffHFFxIgxcTEyPvy8/OlGjVqSMOGDSsSfz9ACgsLM9k3adIkCZD++9//yvvu3Lkj1atXT/L29pZfk8Lrrl+/frHvk/tV9PtOp9NJ9erVk+rWrSulpqaaxBoMBvn/w4YNkwCTn5kkSVKbNm0kPz+/UnNOS0uT7OzspI4dO0o5OTnFniM/P1+qWbOm1KJFC5OYn376SQKk999//4Fyuf/3VpKM7z9AWrFihbzP19dXqlOnjnTnzh153/79+yXA5L1W+PPat29fmWUW5hkeHl7kNSnuZxMZGSkpFArp6tWr8r6wsDCppI+o+9/z/fr1k9RqtXT58mV53/Xr1yU7Ozupc+fO8r7C343AwECTn/HkyZMlpVIppaWlFXs+ofKJbhoBgFdeeYWcnBx++ukn7ty5w08//VRiF8369etxcHCgR48e3Lp1S374+fmh1WrZt2+fHHvvN/o7d+5w69YtnnvuObKzs/njjz9MytVqtbz66qvytlqtpkOHDly5cqVc1+Dv74+fn5+87eXlRd++fdm5c2eR5vTQ0FCT7e3btwMwZcoUk/2F3yrv72KoXbu2yTd8e3t7QkJCOH36NImJiQBoNBosLIy/Ynq9npSUFLRaLY0bN+bUqVNF8g8JCcHOzk7efvnll3F3d5dzqwyvvPIKVlZWrF27Vt63c+dObt26ZfKzMMf27dvp0KGDyYBorVbL6NGjiY+P5/z58ybxw4YNK1fLT0W/706fPk1cXByTJk0qdmzF/e5/zzz33HNlvjd3797NnTt3CA8Px8rKqthznDhxguTkZN544w2TmD59+tCkSZMi770HzaU4169f59y5c4SEhJhMX+7SpQu+vr5ml3e/4lqN7v3ZZGVlcevWLQICApAkidOnT5t9Dr1ez65du+jXrx/169eX97u7uzNkyBAOHTpUpOt
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for (g, group) in res.env.dropna().groupby(\"params_id\"):\n",
    "    params = res.parameters.query(f'params_id == \"{g}\"').iloc[0]\n",
    "    title = f\"{params.generator.rstrip('_graph')} {params.prob_neighbor_spread}\"\n",
    "    prob = group.groupby(by=[\"step\"]).prob_neighbor_spread.mean()\n",
    "    line = \"-\"\n",
    "    if \"barabasi\" in params.generator:\n",
    "        line = \"--\"\n",
    "    prob.rename(title).fillna(0).plot(linestyle=line)\n",
    "plt.title(\"Mean probability for each configuration\")\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for (g, group) in res.agents.dropna().groupby(\"params_id\"):\n",
    "    params = res.parameters.query(f'params_id == \"{g}\"').iloc[0]\n",
    "    title = f\"{params.generator.rstrip('_graph')} {params.prob_neighbor_spread}\"\n",
    "    counts = group.groupby(by=[\"step\", \"state_id\"]).value_counts().unstack()\n",
    "    line = \"-\"\n",
    "    if \"barabasi\" in params.generator:\n",
    "        line = \"--\"\n",
    "    (counts.infected/counts.sum(axis=1)).rename(title).fillna(0).plot(linestyle=line)\n",
    "plt.legend()\n",
    "plt.xlim([9, None]);\n",
    "plt.title(\"Ratio of infected users\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameters\n",
    "\n",
    "The `parameters` dataframe has three keys:\n",
    "\n",
    "* The identifier of the simulation. This will be shared by all iterations launched in the same run\n",
    "* The identifier of the parameters used in the simulation. This will be shared by all iterations that have the exact same set of parameters.\n",
    "* The identifier of the iteration. Each row should have a different iteration identifier\n",
    "\n",
    "There will be a column per each parameter passed to the environment. In this case, that's three: **generator**, **n** and **prob_neighbor_spread**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>generator</th>\n",
       "      <th>n</th>\n",
       "      <th>prob_neighbor_spread</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>iteration_id</th>\n",
       "      <th>params_id</th>\n",
       "      <th>simulation_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">0</th>\n",
       "      <th>39063f8</th>\n",
       "      <th>newspread_1712849444.2514122</th>\n",
       "      <td>erdos_renyi_graph</td>\n",
       "      <td>100</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8f26adb</th>\n",
       "      <th>newspread_1712849444.2514122</th>\n",
       "      <td>barabasi_albert_graph</td>\n",
       "      <td>100</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>92fdcb9</th>\n",
       "      <th>newspread_1712849444.2514122</th>\n",
       "      <td>erdos_renyi_graph</td>\n",
       "      <td>100</td>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cb3dbca</th>\n",
       "      <th>newspread_1712849444.2514122</th>\n",
       "      <td>erdos_renyi_graph</td>\n",
       "      <td>100</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d1fe9c1</th>\n",
       "      <th>newspread_1712849444.2514122</th>\n",
       "      <td>barabasi_albert_graph</td>\n",
       "      <td>100</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "key                                                              generator  \\\n",
       "iteration_id params_id simulation_id                                         \n",
       "0            39063f8   newspread_1712849444.2514122      erdos_renyi_graph   \n",
       "             8f26adb   newspread_1712849444.2514122  barabasi_albert_graph   \n",
       "             92fdcb9   newspread_1712849444.2514122      erdos_renyi_graph   \n",
       "             cb3dbca   newspread_1712849444.2514122      erdos_renyi_graph   \n",
       "             d1fe9c1   newspread_1712849444.2514122  barabasi_albert_graph   \n",
       "\n",
       "key                                                    n prob_neighbor_spread  \n",
       "iteration_id params_id simulation_id                                           \n",
       "0            39063f8   newspread_1712849444.2514122  100                  1.0  \n",
       "             8f26adb   newspread_1712849444.2514122  100                  0.5  \n",
       "             92fdcb9   newspread_1712849444.2514122  100                 0.25  \n",
       "             cb3dbca   newspread_1712849444.2514122  100                  0.5  \n",
       "             d1fe9c1   newspread_1712849444.2514122  100                  1.0  "
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.parameters.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration\n",
    "\n",
    "This dataset is indexed by the identifier of the simulation, and there will be a column per each attribute of the simulation.\n",
    "For instance, there is one for the number of processes used, another one for the path where the results were stored, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>index</th>\n",
       "      <th>version</th>\n",
       "      <th>source_file</th>\n",
       "      <th>name</th>\n",
       "      <th>description</th>\n",
       "      <th>group</th>\n",
       "      <th>backup</th>\n",
       "      <th>overwrite</th>\n",
       "      <th>dry_run</th>\n",
       "      <th>dump</th>\n",
       "      <th>...</th>\n",
       "      <th>num_processes</th>\n",
       "      <th>exporters</th>\n",
       "      <th>model_reporters</th>\n",
       "      <th>agent_reporters</th>\n",
       "      <th>tables</th>\n",
       "      <th>outdir</th>\n",
       "      <th>exporter_params</th>\n",
       "      <th>level</th>\n",
       "      <th>skip_test</th>\n",
       "      <th>debug</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>simulation_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>newspread_1712849444.2514122</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>None</td>\n",
       "      <td>newspread</td>\n",
       "      <td></td>\n",
       "      <td>None</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>[\"&lt;class 'soil.exporters.default'&gt;\"]</td>\n",
       "      <td>{}</td>\n",
       "      <td>{}</td>\n",
       "      <td>{}</td>\n",
       "      <td>/media/j/JsTickData/git/gsi-upm/soil/docs/tuto...</td>\n",
       "      <td>{}</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 28 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                              index version source_file       name  \\\n",
       "simulation_id                                                        \n",
       "newspread_1712849444.2514122      0       2        None  newspread   \n",
       "\n",
       "                             description group backup overwrite dry_run  dump  \\\n",
       "simulation_id                                                                   \n",
       "newspread_1712849444.2514122              None  False      True   False  True   \n",
       "\n",
       "                              ... num_processes  \\\n",
       "simulation_id                 ...                 \n",
       "newspread_1712849444.2514122  ...             1   \n",
       "\n",
       "                                                         exporters  \\\n",
       "simulation_id                                                        \n",
       "newspread_1712849444.2514122  [\"<class 'soil.exporters.default'>\"]   \n",
       "\n",
       "                             model_reporters agent_reporters tables  \\\n",
       "simulation_id                                                         \n",
       "newspread_1712849444.2514122              {}              {}     {}   \n",
       "\n",
       "                                                                         outdir  \\\n",
       "simulation_id                                                                     \n",
       "newspread_1712849444.2514122  /media/j/JsTickData/git/gsi-upm/soil/docs/tuto...   \n",
       "\n",
       "                             exporter_params level skip_test  debug  \n",
       "simulation_id                                                        \n",
       "newspread_1712849444.2514122              {}    30     False  False  \n",
       "\n",
       "[1 rows x 28 columns]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.config.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model reporters\n",
    "\n",
    "The `env` dataframe includes the data collected from the model.\n",
    "The keys in this case are the same as `parameters`, and an additional one: **step**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>agent_count</th>\n",
       "      <th>time</th>\n",
       "      <th>prob_tv_spread</th>\n",
       "      <th>prob_neighbor_spread</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>simulation_id</th>\n",
       "      <th>params_id</th>\n",
       "      <th>iteration_id</th>\n",
       "      <th>step</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">newspread_1712849444.2514122</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">ff1d24a</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">0</th>\n",
       "      <th>0</th>\n",
       "      <td>101</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>101</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>101</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>101</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>101</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                          agent_count  time  \\\n",
       "simulation_id                params_id iteration_id step                      \n",
       "newspread_1712849444.2514122 ff1d24a   0            0             101   0.0   \n",
       "                                                    1             101   1.0   \n",
       "                                                    2             101   2.0   \n",
       "                                                    3             101   3.0   \n",
       "                                                    4             101   4.0   \n",
       "\n",
       "                                                          prob_tv_spread  \\\n",
       "simulation_id                params_id iteration_id step                   \n",
       "newspread_1712849444.2514122 ff1d24a   0            0                0.0   \n",
       "                                                    1                0.0   \n",
       "                                                    2                0.0   \n",
       "                                                    3                0.0   \n",
       "                                                    4                0.0   \n",
       "\n",
       "                                                          prob_neighbor_spread  \n",
       "simulation_id                params_id iteration_id step                        \n",
       "newspread_1712849444.2514122 ff1d24a   0            0                      0.0  \n",
       "                                                    1                      0.0  \n",
       "                                                    2                      0.0  \n",
       "                                                    3                      0.0  \n",
       "                                                    4                      0.0  "
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.env.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Agent reporters\n",
    "\n",
    "This dataframe reflects the data collected for all the agents in the simulation, in every step where data collection was invoked.\n",
    "\n",
    "The key in this dataframe is similar to the one in the `parameters` dataframe, but there will be two more keys: the `step` and the `agent_id`.\n",
    "There will be a column per each agent reporter added to the model. In our case, there is only one: `state_id`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>state_id</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>simulation_id</th>\n",
       "      <th>params_id</th>\n",
       "      <th>iteration_id</th>\n",
       "      <th>step</th>\n",
       "      <th>agent_id</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">newspread_1712849444.2514122</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">ff1d24a</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">0</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">0</th>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>neutral</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>neutral</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>neutral</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>neutral</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                                  state_id\n",
       "simulation_id                params_id iteration_id step agent_id         \n",
       "newspread_1712849444.2514122 ff1d24a   0            0    0            None\n",
       "                                                         1         neutral\n",
       "                                                         2         neutral\n",
       "                                                         3         neutral\n",
       "                                                         4         neutral"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.agents.head()"
   ]
  }
 ],
 "metadata": {
  "hide_code_all_hidden": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "31px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_position": {
    "height": "867px",
    "left": "0px",
    "right": "1670px",
    "top": "106px",
    "width": "250px"
   },
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  },
  "vscode": {
   "interpreter": {
    "hash": "3581132406f7320837865a422f37590c78ed7dabfbcb5bc7771b9d116b13a5cf"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}