Session_18_Data_Collector_Model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "XAnII-29m3r2",
        "wp0VWkylOKr9",
        "BkX5GqjSnAu0"
      ],
      "authorship_tag": "ABX9TyPjZuVDYFSCr0dkbURgLId+",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SFIComplexityExplorer/Mesa-ABM-Tutorial/blob/main/Session_18_Data_Collector_Model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Import Dependencies"
      ],
      "metadata": {
        "id": "XAnII-29m3r2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "\n",
        "try:\n",
        "  import mesa\n",
        "except:\n",
        "  !pip install mesa --quiet\n",
        "import mesa\n",
        "import numpy as np\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "ikSl2Mz0m252",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "766f2e26-b3a6-41d4-dca5-a153222757fc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m39.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.4/66.4 kB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Helper Functions"
      ],
      "metadata": {
        "id": "wp0VWkylOKr9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_distance(pos_1, pos_2):\n",
        "  '''\n",
        "  Calculate the Euclidean distance between two positions\n",
        "\n",
        "  used in trade.move()\n",
        "  '''\n",
        "\n",
        "  x1, y1 = pos_1\n",
        "  x2, y2 = pos_2\n",
        "  dx = x1 - x2\n",
        "  dy = y1 - y2\n",
        "  return math.sqrt(dx**2 + dy**2)\n",
        "\n",
        "def flatten(list_of_lists):\n",
        "  '''\n",
        "  helper function for model datacollector for trade price\n",
        "  collapses agent price list into one list\n",
        "  '''\n",
        "  return [item for sublist in list_of_lists for item in sublist]\n",
        "\n",
        "def geometric_mean(list_of_prices):\n",
        "  '''\n",
        "  find the geometric mean of a list of prices\n",
        "  '''\n",
        "  return np.exp(np.log(list_of_prices).mean())"
      ],
      "metadata": {
        "id": "kg-JVcwzON_b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Resource Classes"
      ],
      "metadata": {
        "id": "BkX5GqjSnAu0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Sugar(mesa.Agent):\n",
        "  \"\"\"\n",
        "  Sugar:\n",
        "  - contains an amount of sugar\n",
        "  - grows 1 amount of sugar at each turn\n",
        "  \"\"\"\n",
        "\n",
        "  def __init__(self, unique_id, model, pos, max_sugar):\n",
        "    super().__init__(unique_id, model)\n",
        "    self.pos = pos\n",
        "    self.amount = max_sugar\n",
        "    self.max_sugar = max_sugar\n",
        "\n",
        "\n",
        "  def step(self):\n",
        "    '''\n",
        "    Sugar growth function, adds one unit of sugar each step until\n",
        "    max amount\n",
        "    '''\n",
        "    self.amount = min([self.max_sugar, self.amount+1])"
      ],
      "metadata": {
        "id": "o1EOk5KMnC55"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Spice(mesa.Agent):\n",
        "  \"\"\"\n",
        "  Spice:\n",
        "  - contains an amount of spice\n",
        "  - grows 1 amount of spice at each turn\n",
        "  \"\"\"\n",
        "\n",
        "  def __init__(self, unique_id, model, pos, max_spice):\n",
        "    super().__init__(unique_id, model)\n",
        "    self.pos = pos\n",
        "    self.amount = max_spice\n",
        "    self.max_spice = max_spice\n",
        "\n",
        "  def step(self):\n",
        "    '''\n",
        "    Spice growth function, adds one unit of spice each step until\n",
        "    max amout\n",
        "    '''\n",
        "    self.amount = min([self.max_spice, self.amount+1])"
      ],
      "metadata": {
        "id": "-oJ35Mx7nXmK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Trader Agent"
      ],
      "metadata": {
        "id": "XYcwNrHqnrPt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Trader(mesa.Agent):\n",
        "  \"\"\"\n",
        "  Trader:\n",
        "  - has a metabolism of sugar and spice\n",
        "  - harvest and trade sugar and spice to survive\n",
        "  \"\"\"\n",
        "\n",
        "\n",
        "  def __init__(self, unique_id, model, pos, moore=False, sugar=0,\n",
        "               spice=0, metabolism_sugar=0, metabolism_spice=0,\n",
        "               vision=0):\n",
        "    super().__init__(unique_id, model)\n",
        "    self.pos = pos\n",
        "    self.moore = moore\n",
        "    self.sugar = sugar\n",
        "    self.spice = spice\n",
        "    self.metabolism_sugar = metabolism_sugar\n",
        "    self.metabolism_spice = metabolism_spice\n",
        "    self.vision = vision\n",
        "    self.prices = []\n",
        "    self.trade_partners = []\n",
        "\n",
        "\n",
        "  def get_sugar(self, pos):\n",
        "    '''\n",
        "    used in self.get_sugar_amount()\n",
        "    '''\n",
        "\n",
        "    this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "    for agent in this_cell:\n",
        "      if type(agent) is Sugar:\n",
        "        return agent\n",
        "    return None\n",
        "\n",
        "\n",
        "  def get_sugar_amount(self,pos):\n",
        "    '''\n",
        "    used in self.move() as part of self.calculate_welfare()\n",
        "    '''\n",
        "\n",
        "    sugar_patch = self.get_sugar(pos)\n",
        "    if sugar_patch:\n",
        "      return sugar_patch.amount\n",
        "    return 0\n",
        "\n",
        "  def get_spice(self, pos):\n",
        "    '''\n",
        "    used in self.get_spice_amount()\n",
        "    '''\n",
        "\n",
        "    this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "    for agent in this_cell:\n",
        "      if type(agent) is Spice:\n",
        "        return agent\n",
        "    return None\n",
        "\n",
        "  def get_spice_amount(self, pos):\n",
        "    '''\n",
        "    used in self.move() as part of self.calculate_welfare()\n",
        "    '''\n",
        "\n",
        "    spice_patch = self.get_spice(pos)\n",
        "    if spice_patch:\n",
        "      return spice_patch.amount\n",
        "    return 0\n",
        "\n",
        "  def get_trader(self, pos):\n",
        "      '''\n",
        "      helper function used in self.trade_with_neighbors()\n",
        "      '''\n",
        "\n",
        "      this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "\n",
        "      for agent in this_cell:\n",
        "        if isinstance(agent, Trader):\n",
        "          return agent\n",
        "\n",
        "\n",
        "  def is_occupied_by_other(self,pos):\n",
        "    '''\n",
        "    helper function part 1 of self.move()\n",
        "    '''\n",
        "\n",
        "    if pos == self.pos:\n",
        "      # agent's position is considered unoccupied as agent can stay there\n",
        "      return False\n",
        "    # get contents of each cell in neighborhood\n",
        "    this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "    for a in this_cell:\n",
        "      # see if occupied by another agent\n",
        "      if isinstance(a, Trader):\n",
        "        return True\n",
        "    return False\n",
        "\n",
        "  def calculate_welfare(self, sugar, spice):\n",
        "    '''\n",
        "    helper function\n",
        "\n",
        "    part 2 self.move()\n",
        "    self.trade()\n",
        "    '''\n",
        "\n",
        "    # calculate total resources\n",
        "    m_total = self.metabolism_sugar + self.metabolism_spice\n",
        "    # Cobb-Douglas functional form; starting on p. 97 on Growing Artificial Societies\n",
        "    return sugar**(self.metabolism_sugar/m_total) * spice**(\n",
        "        self.metabolism_spice/m_total)\n",
        "\n",
        "\n",
        "  def is_starved(self):\n",
        "    '''\n",
        "    Helper function for self.maybe_die()\n",
        "    '''\n",
        "\n",
        "    return (self.sugar <= 0) or (self.spice <= 0)\n",
        "\n",
        "  def calculate_MRS(self, sugar, spice):\n",
        "    '''\n",
        "    Helper function\n",
        "\n",
        "    - self.trade()\n",
        "    - self.maybe_sell_spice\n",
        "\n",
        "    Determines what trader agent is needs and can give up\n",
        "    '''\n",
        "\n",
        "    return (spice/self.metabolism_spice) / (sugar/self.metabolism_sugar)\n",
        "\n",
        "  def calculate_sell_spice_amount(self, price):\n",
        "    '''\n",
        "    helper function for self.maybe_sell_spice() which is called from\n",
        "    self.trade()\n",
        "    '''\n",
        "\n",
        "    if price >= 1:\n",
        "      sugar = 1\n",
        "      spice = int(price)\n",
        "    else:\n",
        "      sugar = int(1/price)\n",
        "      spice = 1\n",
        "    return sugar, spice\n",
        "\n",
        "  def sell_spice(self, other, sugar, spice):\n",
        "    '''\n",
        "    used in self.maybe_sell_spice()\n",
        "\n",
        "    exchanges sugar and spice between traders\n",
        "    '''\n",
        "\n",
        "    self.sugar += sugar\n",
        "    other.sugar -= sugar\n",
        "    self.spice -= spice\n",
        "    other.spice += spice\n",
        "\n",
        "\n",
        "  def maybe_sell_spice(self, other, price, welfare_self, welfare_other):\n",
        "    '''\n",
        "    helper function for self.trade()\n",
        "    '''\n",
        "\n",
        "    sugar_exchanged, spice_exchanged = self.calculate_sell_spice_amount(price)\n",
        "\n",
        "    # Assess new sugar and spice amount - what if change did occur\n",
        "    self_sugar = self.sugar + sugar_exchanged\n",
        "    other_sugar = other.sugar - sugar_exchanged\n",
        "    self_spice = self.spice - spice_exchanged\n",
        "    other_spice = other.spice + spice_exchanged\n",
        "\n",
        "    # double check to ensure agents have resources\n",
        "\n",
        "    if ((self_sugar <= 0) or\n",
        "        (other_sugar <=0) or\n",
        "        (self_spice <= 0) or\n",
        "        (other_spice <= 0)):\n",
        "      return False\n",
        "\n",
        "    # trade criteria #1 - are both agents better off?\n",
        "    both_agents_better_off = (\n",
        "        (welfare_self < self.calculate_welfare(self_sugar, self_spice)) and\n",
        "        (welfare_other < other.calculate_welfare(other_sugar, other_spice)))\n",
        "\n",
        "    # trade criteria #2 is their mrs crossing\n",
        "    mrs_not_crossing = self.calculate_MRS(self_sugar, self_spice\n",
        "                                          ) > other.calculate_MRS(\n",
        "                                              other_sugar, other_spice)\n",
        "\n",
        "    if not (both_agents_better_off and mrs_not_crossing):\n",
        "      return False\n",
        "\n",
        "    # criteria met, execute trade\n",
        "    self.sell_spice(other, sugar_exchanged, spice_exchanged)\n",
        "\n",
        "    return True\n",
        "\n",
        "\n",
        "  def trade(self, other):\n",
        "    '''\n",
        "    helper function used in trade_with_neighbors()\n",
        "\n",
        "    other is a trader agent object\n",
        "    '''\n",
        "\n",
        "    # sanity check to verify code is working as expected\n",
        "    assert self.sugar > 0\n",
        "    assert self.spice > 0\n",
        "    assert other.sugar > 0\n",
        "    assert other.spice > 0\n",
        "\n",
        "    # calculate marginal rate of subsitution in Growing Artificial Socieites p. 101\n",
        "    mrs_self = self.calculate_MRS(self.sugar, self.spice)\n",
        "    mrs_other = other.calculate_MRS(other.sugar, other.spice)\n",
        "\n",
        "    #calculate each agents welfare\n",
        "    welfare_self = self.calculate_welfare(self.sugar, self.spice)\n",
        "    welfare_other = other.calculate_welfare(other.sugar, other.spice)\n",
        "\n",
        "    if math.isclose(mrs_self, mrs_other):\n",
        "      return\n",
        "\n",
        "    # calcualte price\n",
        "    price = math.sqrt(mrs_self*mrs_other)\n",
        "\n",
        "    if mrs_self > mrs_other:\n",
        "      # self is a sugar buyer, spice seller\n",
        "      sold = self.maybe_sell_spice(other, price, welfare_self, welfare_other)\n",
        "      # no trade - criteria not met\n",
        "      if not sold:\n",
        "        return\n",
        "    else:\n",
        "      # self is a spice buyer, sugar seller\n",
        "      sold = other.maybe_sell_spice(self, price, welfare_other, welfare_self)\n",
        "      # no trade - criteria not met\n",
        "      if not sold:\n",
        "        return\n",
        "\n",
        "    # Capture data\n",
        "    self.prices.append(price)\n",
        "    self.trade_partners.append(other.unique_id)\n",
        "\n",
        "    # continue trading\n",
        "    self.trade(other)\n",
        "\n",
        "  ######################################################################\n",
        "  #                                                                    #\n",
        "  #                      MAIN TRADE FUNCTIONS                          #\n",
        "  #                                                                    #\n",
        "  ######################################################################\n",
        "\n",
        "\n",
        "  def move(self):\n",
        "    '''\n",
        "    Function for trader agent to identify optimal move for each step in 4 parts\n",
        "    1 - identify all possible moves\n",
        "    2 - determine which move maximizes welfare\n",
        "    3 - find closest best option\n",
        "    4 - move\n",
        "    '''\n",
        "\n",
        "    # 1. identify all possible moves\n",
        "\n",
        "    neighbors = [i\n",
        "                 for i in self.model.grid.get_neighborhood(\n",
        "                   self.pos, self.moore, True, self.vision\n",
        "                 ) if not self.is_occupied_by_other(i)]\n",
        "\n",
        "    # 2. determine which move maximizes welfare\n",
        "\n",
        "    welfares = [\n",
        "        self.calculate_welfare(\n",
        "            self.sugar + self.get_sugar_amount(pos),\n",
        "            self.spice + self.get_spice_amount(pos))\n",
        "        for pos in neighbors\n",
        "    ]\n",
        "\n",
        "    # 3. Find closest best option\n",
        "\n",
        "    # find the highest welfare in welfares\n",
        "    max_welfare = max(welfares)\n",
        "    # get the index of max welfare cells\n",
        "    candidate_indices = [i for i in range(len(welfares))\n",
        "                        if math.isclose(welfares[i], max_welfare)]\n",
        "\n",
        "    # convert index to positions of those cells\n",
        "    candidates = [neighbors[i] for i in candidate_indices]\n",
        "\n",
        "    min_dist = min(get_distance(self.pos, pos) for pos in candidates)\n",
        "\n",
        "    final_candidates = [ pos for pos in candidates\n",
        "                       if math.isclose(get_distance(self.pos, pos), min_dist, rel_tol=1e-02\n",
        "                                       )]\n",
        "    self.random.shuffle(final_candidates)\n",
        "\n",
        "    # 4. Move Agent\n",
        "    self.model.grid.move_agent(self, final_candidates[0])\n",
        "\n",
        "  def eat(self):\n",
        "    # get sugar\n",
        "    sugar_patch = self.get_sugar(self.pos)\n",
        "\n",
        "    if sugar_patch:\n",
        "        self.sugar += sugar_patch.amount\n",
        "        sugar_patch.amount = 0\n",
        "    self.sugar -= self.metabolism_sugar\n",
        "\n",
        "    # get_spice\n",
        "    spice_patch = self.get_spice(self.pos)\n",
        "\n",
        "    if spice_patch:\n",
        "        self.spice += spice_patch.amount\n",
        "        spice_patch.amount = 0\n",
        "    self.spice -= self.metabolism_spice\n",
        "\n",
        "  def maybe_die(self):\n",
        "    '''\n",
        "    Function to remove Traders who have consumed all their sugar or spice\n",
        "    '''\n",
        "\n",
        "    if self.is_starved():\n",
        "      self.model.grid.remove_agent(self)\n",
        "      self.model.schedule.remove(self)\n",
        "\n",
        "  def trade_with_neighbors(self):\n",
        "    '''\n",
        "    Function for trader agents to decide who to trade with in three parts\n",
        "\n",
        "    1- identify neighbors who can trade\n",
        "    2- trade (2 sessions)\n",
        "    3- collect data\n",
        "    '''\n",
        "\n",
        "    neighbor_agents = [self.get_trader(pos) for pos in self.model.grid.get_neighborhood(\n",
        "        self.pos, self.moore, False, self.vision) if self.is_occupied_by_other(pos)\n",
        "    ]\n",
        "\n",
        "    if len(neighbor_agents) == 0:\n",
        "      return\n",
        "\n",
        "\n",
        "    # iterate through traders in neighboring cells and trade\n",
        "    for a in neighbor_agents:\n",
        "      if a:\n",
        "        self.trade(a)\n",
        "\n",
        "    return"
      ],
      "metadata": {
        "id": "t51BNfwUnt53"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Model Class"
      ],
      "metadata": {
        "id": "SRrU2ABBoF0i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SugarscapeG1mt(mesa.Model):\n",
        "  \"\"\"\n",
        "  Manager class to run Sugarscape with Traders\n",
        "  \"\"\"\n",
        "\n",
        "\n",
        "  def __init__(self, width=50,height=50, initial_population=200,\n",
        "               endowment_min=25, endowment_max=50, metabolism_min=1,\n",
        "               metabolism_max=5, vision_min=1, vision_max=5):\n",
        "\n",
        "    #Initiate width and heigh of sugarscape\n",
        "    self.width = width\n",
        "    self.height = height\n",
        "    #Initiate population attributes\n",
        "    self.initial_population = initial_population\n",
        "    self.endowment_min = endowment_min\n",
        "    self.endowment_max = endowment_max\n",
        "    self.metabolism_min = metabolism_min\n",
        "    self.metabolism_max = metabolism_max\n",
        "    self.vision_min = vision_min\n",
        "    self.vision_max = vision_max\n",
        "\n",
        "    # initiate activation schedule\n",
        "    self.schedule = mesa.time.RandomActivationByType(self)\n",
        "    # initiate mesa grid class\n",
        "    self.grid = mesa.space.MultiGrid(self.width, self.height, torus=False)\n",
        "    # initiate datacollector\n",
        "    self.datacollector = mesa.DataCollector(\n",
        "        {\"Trader\": lambda m: m.schedule.get_type_count(Trader),\n",
        "         \"Trade Volume\": lambda m: sum(len(a.trade_partners)\n",
        "         for a in m.schedule.agents_by_type[Trader].values()),\n",
        "         \"Price\": lambda m: geometric_mean(flatten([a.prices for a in m.schedule.agents_by_type[Trader].values()]))}\n",
        "    )\n",
        "\n",
        "\n",
        "    #read in landscape file from supplmentary material\n",
        "    sugar_distribution =np.genfromtxt(\"/content/drive/MyDrive/sugar-map.txt\")\n",
        "    spice_distribution = np.flip(sugar_distribution, 1)\n",
        "\n",
        "    agent_id = 0\n",
        "    for _,(x,y) in self.grid.coord_iter():\n",
        "      max_sugar = sugar_distribution[x,y]\n",
        "      if max_sugar > 0:\n",
        "        sugar = Sugar(agent_id, self, (x,y), max_sugar)\n",
        "        self.schedule.add(sugar)\n",
        "        self.grid.place_agent(sugar, (x,y))\n",
        "        agent_id += 1\n",
        "\n",
        "      max_spice = spice_distribution[x,y]\n",
        "      if max_spice > 0:\n",
        "        spice = Spice(agent_id, self, (x,y), max_spice)\n",
        "        self.schedule.add(spice)\n",
        "        self.grid.place_agent(spice, (x,y))\n",
        "        agent_id += 1\n",
        "\n",
        "    for i in range(self.initial_population):\n",
        "      #get agent position\n",
        "      x = self.random.randrange(self.width)\n",
        "      y = self.random.randrange(self.height)\n",
        "      #see Growing Artificial Societies p. 108 for initialization\n",
        "      #give agents initial endowment\n",
        "      sugar = int(self.random.uniform(self.endowment_min, self.endowment_max+1))\n",
        "      spice = int(self.random.uniform(self.endowment_min, self.endowment_max+1))\n",
        "      #give agents initial metabolism\n",
        "      metabolism_sugar = int(self.random.uniform(self.metabolism_min, self.metabolism_max+1))\n",
        "      metabolism_spice = int(self.random.uniform(self.metabolism_min, self.metabolism_max+1))\n",
        "      #give agents vision\n",
        "      vision = int(self.random.uniform(self.vision_min, self.vision_max+1))\n",
        "      #create Trader object\n",
        "      trader = Trader(agent_id,\n",
        "                      self,\n",
        "                      (x,y),\n",
        "                      moore = False,\n",
        "                      sugar = sugar,\n",
        "                      spice = spice,\n",
        "                      metabolism_sugar = metabolism_sugar,\n",
        "                      metabolism_spice = metabolism_spice,\n",
        "                      vision = vision)\n",
        "      #place agent\n",
        "      self.grid.place_agent(trader, (x,y))\n",
        "      self.schedule.add(trader)\n",
        "      agent_id += 1\n",
        "\n",
        "  def randomize_traders(self):\n",
        "    '''\n",
        "    helper function for self.step()\n",
        "\n",
        "    puts traders in randomized list for step function\n",
        "    '''\n",
        "\n",
        "    trader_shuffle = list(self.schedule.agents_by_type[Trader].values())\n",
        "    self.random.shuffle(trader_shuffle)\n",
        "\n",
        "    return trader_shuffle\n",
        "\n",
        "\n",
        "  def step(self):\n",
        "    '''\n",
        "    Unique step function that does staged activation of sugar and spice\n",
        "    and then randomly activates traders\n",
        "    '''\n",
        "    # step Sugar agents\n",
        "    for sugar in self.schedule.agents_by_type[Sugar].values():\n",
        "      sugar.step()\n",
        "\n",
        "    # step Spice agents\n",
        "    for spice in self.schedule.agents_by_type[Spice].values():\n",
        "      spice.step()\n",
        "\n",
        "    # step trader agents\n",
        "    # to account for agent death and removal we need a seperate data strcuture to\n",
        "    # iterate\n",
        "    trader_shuffle = self.randomize_traders()\n",
        "\n",
        "    for agent in trader_shuffle:\n",
        "      agent.prices = []\n",
        "      agent.trade_partners = []\n",
        "      agent.move()\n",
        "      agent.eat()\n",
        "      agent.maybe_die()\n",
        "\n",
        "    trader_shuffle = self.randomize_traders()\n",
        "\n",
        "    for agent in trader_shuffle:\n",
        "      agent.trade_with_neighbors()\n",
        "\n",
        "    self.schedule.steps += 1 #important for data collector to track number of steps\n",
        "\n",
        "    # collect model level data\n",
        "    self.datacollector.collect(self)\n",
        "\n",
        "  def run_model(self, step_count=1000):\n",
        "\n",
        "    for i in range(step_count):\n",
        "      self.step()"
      ],
      "metadata": {
        "id": "7DTonjahn2BT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Run Sugarscape"
      ],
      "metadata": {
        "id": "_KHKfeD9oiYo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = SugarscapeG1mt()\n",
        "model.run_model()\n"
      ],
      "metadata": {
        "id": "at455urSol7b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e5ff4b1-c839-4a2c-8c7a-2115a84731d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-2-acd95e4196bc>:25: RuntimeWarning: Mean of empty slice.\n",
            "  return np.exp(np.log(list_of_prices).mean())\n",
            "/usr/local/lib/python3.10/dist-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars\n",
            "  ret = ret.dtype.type(ret / rcount)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Analyze Data"
      ],
      "metadata": {
        "id": "XQ7ykQMWoRyU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "results = model.datacollector.get_model_vars_dataframe()\n",
        "\n",
        "results"
      ],
      "metadata": {
        "id": "vemquyVptT3Z",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 423
        },
        "outputId": "4aa5929d-53dd-492d-f045-9d71fa72dd46"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "     Trader  Trade Volume     Price\n",
              "0       200           723  0.966478\n",
              "1       200           149  1.003595\n",
              "2       200           116  1.046706\n",
              "3       200           128  1.049242\n",
              "4       200           122  0.832239\n",
              "..      ...           ...       ...\n",
              "995      51             6  1.013715\n",
              "996      51             4  1.031490\n",
              "997      51             3  0.999634\n",
              "998      51             3  1.024906\n",
              "999      51             1  1.003934\n",
              "\n",
              "[1000 rows x 3 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-0811dce4-5a73-4563-8a96-0a79a9a928e6\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <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>Trader</th>\n",
              "      <th>Trade Volume</th>\n",
              "      <th>Price</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>200</td>\n",
              "      <td>723</td>\n",
              "      <td>0.966478</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>200</td>\n",
              "      <td>149</td>\n",
              "      <td>1.003595</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>200</td>\n",
              "      <td>116</td>\n",
              "      <td>1.046706</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>200</td>\n",
              "      <td>128</td>\n",
              "      <td>1.049242</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>200</td>\n",
              "      <td>122</td>\n",
              "      <td>0.832239</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>995</th>\n",
              "      <td>51</td>\n",
              "      <td>6</td>\n",
              "      <td>1.013715</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>996</th>\n",
              "      <td>51</td>\n",
              "      <td>4</td>\n",
              "      <td>1.031490</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>997</th>\n",
              "      <td>51</td>\n",
              "      <td>3</td>\n",
              "      <td>0.999634</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>998</th>\n",
              "      <td>51</td>\n",
              "      <td>3</td>\n",
              "      <td>1.024906</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>999</th>\n",
              "      <td>51</td>\n",
              "      <td>1</td>\n",
              "      <td>1.003934</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>1000 rows × 3 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-0811dce4-5a73-4563-8a96-0a79a9a928e6')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-0811dce4-5a73-4563-8a96-0a79a9a928e6 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-0811dce4-5a73-4563-8a96-0a79a9a928e6');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot number of agents per time step\n",
        "results.plot(y = \"Trader\", use_index=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "lr0rYpIpovMg",
        "outputId": "28e77912-aede-46a2-e167-839041068ba5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Axes: >"
            ]
          },
          "metadata": {},
          "execution_count": 15
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot trade price per step\n",
        "\n",
        "y = list(results[\"Price\"])\n",
        "x = range(1000)\n",
        "\n",
        "plt.scatter(x,y, s=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "MIAxl_Oqo7M4",
        "outputId": "36de3197-622a-49d3-d982-e3a6ed251a05"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7f22d7afff70>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot trade volume\n",
        "\n",
        "plt.bar(results.index[10:], results[\"Trade Volume\"][10:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "BhVtqXWNpVVD",
        "outputId": "25aa5b68-f6e0-4c5b-9529-23b0f12a607b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<BarContainer object of 990 artists>"
            ]
          },
          "metadata": {},
          "execution_count": 17
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot trade volume improved\n",
        "\n",
        "for i in range(1000):\n",
        "  plt.vlines(i,0,results[\"Trade Volume\"][i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "fJL9UPatpgOO",
        "outputId": "334f2070-94d1-49a4-d869-88d4b44a4e83"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ql0x0DcEqMVF"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}