Session_8_Sugar_and_Spice_Step_Functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Session 8 - Sugar and Spice Step Functions.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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/edgeofchaos42/ComplexityExplorer/blob/main/Session_8_Sugar_and_Spice_Step_Functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1- Review lesson 7 and intro\n",
        "\n",
        "Script Notes: \n",
        "\n",
        "In lesson 7 we introduced traders into our model. Remember if you shut down your colab kernel you will need to add the sugar-map.txt file again or you can mount your drive and not have to load it every time  \n",
        "\n",
        "To do this (1) load the sugar map into your Google drive, (2) click the mount drive button. then (3) update the path\n",
        "\n",
        "Now we want to start making our agents do things. In this lesson we are going to add the sugar and spice step functions.\n",
        "\n",
        "The way Mesa is developed following ABM convention is that it will look for step functions for each agent in the schedule. So users must call the function that causes each agent to take action **step**.\n",
        "\n",
        "\n",
        "*Review each class and model set up*"
      ],
      "metadata": {
        "id": "1WxZVj47O4g0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u1WsC1FjpnaU",
        "outputId": "46283a5d-9b26-4073-b4c9-6bd1670fb59a"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "try: \n",
        "  import mesa\n",
        "except: \n",
        "  !pip install mesa --quiet\n",
        "  import mesa\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "\n",
        "%matplotlib inline "
      ],
      "metadata": {
        "id": "R-uRKmZUxS2S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c947e9a6-1851-4d27-b7f1-bdddbedd6473"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[K     |████████████████████████████████| 2.5 MB 5.2 MB/s \n",
            "\u001b[K     |████████████████████████████████| 596 kB 46.7 MB/s \n",
            "\u001b[K     |████████████████████████████████| 64 kB 2.3 MB/s \n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 1: Add sugar step\n",
        "\n",
        "**Part 1**\n",
        "\n",
        "-----\n",
        "First we add a function to the class called step\n",
        "\n",
        "\n",
        "Again there is several ways to code this, using a compact line of code we are going to exploit python min function and make a list that compares the max sugar the cell should have with the amount it does have and go with whichever the minimum is. This ensure we never go above the max sugar but allows the sugar to grow back one at a time. \n",
        "\n",
        "Now that this is complete we need the model to actually call the function so steps can proceed, so let's move down to the main model class. \n",
        "\n"
      ],
      "metadata": {
        "id": "joz_cOICJSDB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Sugar(mesa.Agent):\n",
        "    \"\"\"\n",
        "    Sugar is a FSM that\n",
        "    - contains an amount of sugar\n",
        "    - grows 1 amount of sugar at each turn (rule G1).\n",
        "    \"\"\"\n",
        "    \n",
        "    \n",
        "    def __init__(self, unique_id, model, pos, max_sugar): \n",
        "      super().__init__(unique_id, model) #part 3\n",
        "      self.pos = pos\n",
        "      self.amount = max_sugar\n",
        "      self.max_sugar = max_sugar\n",
        "\n",
        "    def step(self): #Part 1\n",
        "      self.amount = min([self.max_sugar,self.amount+1])\n",
        "      # print(self.unique_id, self.amount, self.max_sugar) #delete for part 4\n",
        "      "
      ],
      "metadata": {
        "id": "qLn3pp5X1Cp2"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Spice(mesa.Agent):\n",
        "    \"\"\"\n",
        "    Spice is a FSM that\n",
        "    - contains an amount of spice\n",
        "    - grows 1 amount of spice at each turn. (rule G1)\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): #Part 1\n",
        "      self.amount = min([self.max_spice,self.amount+1])\n",
        "      print(self.unique_id, self.amount, self.max_spice) #delete for part 4\n",
        "\n",
        "\n",
        "       "
      ],
      "metadata": {
        "id": "vWcWMp2My8tJ"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Trader(mesa.Agent):\n",
        "    \"\"\"\n",
        "    TraderAgent is a \n",
        "    - has a metabolism for sugar and spice\n",
        "    - harvest and trades sugar and spice to survive and thrive\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 = False \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",
        "\n",
        "      "
      ],
      "metadata": {
        "id": "89x-JNt-zQmK"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Add step function and run model\n",
        "\n",
        "Now we want to add step function for the model. However as discussed in lesson two this model has a unique set up  in that is does a staged activation - sugar grows, spice grows, then agents do each one of their steps, move, consume, trade, this is a staged, random activation. Mesa has staged activation and random activation by type but not a combined approach. However, the great thing about using python and Mesa is we can easily set this up ourselves so Mesa really becomes a menu of options that users can customize as they see fit. As the results are robust, we could do a simple randomactivation by type and make each agent move, consume, trade but for reasons discussed earlier we decided to replicate the original model more closely.    \n",
        "\n",
        "The result is our step function will be slighlty more complex than what you can see in other mesa examples. \n",
        "\n",
        "**Part 2**\n",
        "\n",
        "------\n",
        "\n",
        "First thing we do is add the step function for the model and then since we are using activation by type which is just a dictionary of the different types of agents we will call the Sugar class and iterate through its values\n",
        "\n",
        "**Part 3a**\n",
        "\n",
        "--------\n",
        "\n",
        "Now we want to iterate through some number of steps. There are different ways to do this, for exmaple call step from our model object we created, but in this case we are going to create function called run model in or main sugarscapeg1mt class\n",
        "\n",
        "I will add a key word argument called step count and then create a loop for that number of steps, I will default to 1000 as that is what is in the book but then I will test to make sure the sugar agent is doing what we want for 5 steps.\n",
        "\n",
        "So first I will add a print statement then and call the run_model function"
      ],
      "metadata": {
        "id": "QuNoa2uzKon_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SugarscapeG1mt(mesa.Model):\n",
        "\n",
        "  def __init__(self, width=50, height=50, initial_population=100,\n",
        "               endowment_min =25, endowment_max =50, metabolism_min =1,\n",
        "               metabolism_max = 5, vision_min = 1, vision_max =5): \n",
        "    \n",
        "    self.width = width\n",
        "    self.height = height\n",
        "    self.initial_population =initial_population #part 0\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",
        "\n",
        "    self.schedule = mesa.time.RandomActivationByType(self)\n",
        "    self.grid = mesa.space.MultiGrid(self.width, self.height, torus=False)\n",
        "\n",
        "    sugar_distribution = np.genfromtxt(\"/content/drive/MyDrive/sugar-map.txt\") \n",
        "    spice_distribution = spice = np.flip(sugar_distribution,1)\n",
        "    \n",
        "    #ensure unique id\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.grid.place_agent(sugar, (x, y))\n",
        "        #Place Agent\n",
        "        self.schedule.add(sugar) \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.grid.place_agent(spice,(x,y))\n",
        "        self.schedule.add(spice)\n",
        "        agent_id += 1\n",
        "         \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 GAS page 108 for parameters initialization.\n",
        "      # Each agent is endowed by a random amount of sugar and spice\n",
        "      sugar = self.random.uniform(self.endowment_min, self.endowment_max+1) \n",
        "      spice = self.random.uniform(self.endowment_min, self.endowment_max+1) \n",
        "      #add metabolism also on page #108\n",
        "      # Each agent's phenotype is initialized with uniform value\n",
        "      metabolism_sugar = self.random.uniform(self.metabolism_min, self.metabolism_max)\n",
        "      metabolism_spice = self.random.uniform(self.metabolism_min, self.metabolism_max)\n",
        "      vision = int(self.random.uniform(self.vision_min, self.vision_max))\n",
        "      trader = Trader(\n",
        "                agent_id,\n",
        "                self,\n",
        "                (x, y),\n",
        "                False,\n",
        "                sugar,\n",
        "                spice,\n",
        "                metabolism_sugar,\n",
        "                metabolism_spice,\n",
        "                vision,\n",
        "            )\n",
        "      self.grid.place_agent(trader, (x, y))\n",
        "      self.schedule.add(trader)\n",
        "      agent_id += 1\n",
        "\n",
        "  def step(self): #part 2\n",
        "    for sugar in self.schedule.agents_by_type[Sugar].values(): \n",
        "      sugar.step()\n",
        "\n",
        "    #part 4\n",
        "    for spice in self.schedule.agents_by_type[Spice].values(): \n",
        "      spice.step()\n",
        "\n",
        "    self.schedule.time +=1\n",
        "    self.schedule.steps += 1\n",
        "    \n",
        "\n",
        "  #part 3\n",
        "  def run_model(self, step_count=1000):\n",
        "\n",
        "    for i in range(step_count):\n",
        "      self.step()\n",
        "      \n",
        "\n",
        "    #self.schedule.step()_\n",
        "\n",
        "        "
      ],
      "metadata": {
        "id": "V3yTkyWz0Pi9"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Model Run \n",
        "\n",
        "**Part 3b**\n",
        "\n",
        "-----------\n",
        "\n",
        "Now I will add the run model function and as we can see we get agents with the same values for max_sugar and amount as expected. \n",
        "\n",
        "Another way to do this would be to run a loop here for example if we comment out the run_model and call the step function, we see the same result. \n",
        "\n",
        "\n",
        "**Part 4**\n",
        "\n",
        "-----------\n",
        "\n",
        "However, there is a bug, since we are not calling mesa schedule.step function which would look like this there is bug as our steps and time are not advancing. We can see this with a print statement. first lets get rid our our sugar print statement call our time and steps and see what there values are.\n",
        "\n",
        "As you can see they remain 0. This will have implications for our data collection later on so let's fix this now. In the step functin we will simply update the schedule values for time and steps. \n",
        "\n",
        "If you are new to ABMs this may see a little annoying but as you make more complex models this ability to shape the details becomes critical and highly desirable, thanks to the dynamics of complex system Mesa will never be able to account for all variations, so our goal is to provide the major items that you can customize as you need to.\n",
        "\n",
        "Now that we have tested and know it works we can add the step function for the spice agent, which will be the same and call it from the model step function. We update those cells and test and viola it works. \n",
        "\n",
        "This concludes session 8, and next we will starting adding behaviors to the traders, specifically movement. "
      ],
      "metadata": {
        "id": "kYXO-SNTPnC-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = SugarscapeG1mt()\n",
        "model.run_model(step_count=5) #part 3\n",
        "\n",
        "'''\n",
        "for i in range(5):\n",
        "  model.step()\n",
        "'''"
      ],
      "metadata": {
        "id": "wbZ1-r5q1fe1"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}