Session_9_Traders_move_part_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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_9_Traders_move_part_1.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 8 and intro\n",
        "\n",
        "Script Notes: \n",
        "\n",
        "In lesson 8 we introduced the sugar and spice step functions and in this lesson we begin the trader functions which will take up the next several lessons. \n",
        "\n",
        "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",
        "*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": "CCWF0WnCu1_3",
        "outputId": "efb335bc-5d11-4941-9d14-91e4f1280104"
      },
      "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": "84c5757f-b408-469e-bab4-6e63f9624922"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[K     |████████████████████████████████| 1.8 MB 7.5 MB/s \n",
            "\u001b[K     |████████████████████████████████| 66 kB 4.6 MB/s \n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "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",
        "      \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",
        "       "
      ],
      "metadata": {
        "id": "vWcWMp2My8tJ"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Add agent move move function \n",
        "\n",
        "**Part 1**\n",
        "\n",
        "------------\n",
        "\n",
        "So we added the call from the main model so lets build a simple move function just to make sure it calls and is moving agents. \n",
        "\n",
        "No we know our move function is being called we can start the rather complicated process of detemrining as an agent wehre to move\n",
        "\n",
        "To move we want to \n",
        "--see all our options, based on our vision using left, right, up down of our von neuman neighborhood. \n",
        "--calculate which one is the best\n",
        "--then move there\n",
        "\n",
        "For this session we will just do see all the options. \n",
        "\n",
        "**Part 2**\n",
        "\n",
        "------------\n",
        "\n",
        "To do this we will make a list of all the cells in our vision and use Mesa's get_neighborhood function and python's list concantenation. Which you can see at [line 243](https://github.com/projectmesa/mesa/blob/de88728f6c2e28bb7e88170b47618c627b586c0d/mesa/space.py#L243) in the space.py code. This function has 5 parameters with various defaults. First you need to pass in a position which is just the agents position, next is a boolean for whether or not we are using the moore neighborhood as this is an attirbute of the agent we can just pass in self.moore. Next is another boolean whether or not to include the position the agent is in. Per growing artifical societies we say True,finally an integer for the radius the agent can see which is the agent vision. \n",
        "\n",
        "now lets do a print statement to make sure it works. As you can see Mesa returns a list of tuples which are the grid positions that meet the criteria radius and type of neighborhood. \n",
        "\n",
        "**Part 3**\n",
        "\n",
        "------------\n",
        "\n",
        "However there is a complication. Per Growing Artifcial Societies, they cannot move to a cell if a Trader agent is already there. This is one more example where if we kept the agent order the same everytime it would change the results. So we will create a special function to check if a Trader is in the cell. called is_occupied\n",
        "\n",
        "We will then pass in the position and use mesa get_cell_list_content function which is [line 387](https://github.com/projectmesa/mesa/blob/de88728f6c2e28bb7e88170b47618c627b586c0d/mesa/space.py#L387) in space.py\n",
        "and as you can see it accepts an iterable such as a tuple and returns the contents in a list. We must also exclude the position the agent is at as we can stay at this position.  \n",
        "\n",
        "So we will then iterate through that list and if the object is a Trader we will return True and if not we will return false. \n",
        "\n",
        "if a trader is in the list so True we will not add it. \n"
      ],
      "metadata": {
        "id": "9Mxm0q6pAxUq"
      }
    },
    {
      "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",
        "    #part 3\n",
        "    def is_occupied_by_other(self, pos): \n",
        "      if pos == self.pos: \n",
        "        # We consider the agent's own position to be \"unoccupied\" in\n",
        "        # the sense that it is one of the legal positions the agent can occupy.\n",
        "        return False\n",
        "      this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "      for a in this_cell:\n",
        "          # Occupied by other agent\n",
        "          if isinstance(a, Trader) and a.pos != self.pos:\n",
        "              return True\n",
        "      return False\n",
        "       \n",
        "    def move(self): \n",
        "\n",
        "      #print(\"I am agent {} and am about to move\".format(self.unique_id)) #part 1\n",
        "      \n",
        "      # 1. Get neighbors within vision\n",
        "\n",
        "      neighbors = [i \n",
        "                   for i in self.model.grid.get_neighborhood(\n",
        "                       self.pos, self.moore,True, self.vision\n",
        "                       )\n",
        "                   if not self.is_occupied_by_other(i)\n",
        "      ]\n",
        "\n",
        "      print(len(neighbors), self.vision)\n",
        "\n"
      ],
      "metadata": {
        "id": "89x-JNt-zQmK"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Add Trader randomize and move\n",
        "\n",
        "**Part 1:**\n",
        "\n",
        "-----------\n",
        "\n",
        "To begin we will ad the move traders move to to main model class sugascapeg1mt.\n",
        "\n",
        "As we do not want to give any agent a mover advantage, for example if the same agent goes first all the time they will always get the prime sugar and spice point in their vision. We need to randomize the agents. \n",
        "\n",
        "As Mesa is mostly in python you can see the code and underlying data structures easily. RandomActivationByType stores all agents in a dictionary by type we can see this again with some simple print functions and running the model for one step. \n",
        "\n",
        "Now a challenge with traders is agents can die and this creates a lot of complications as the datastrcutures are being updated as agents move. For example, you can not change a dictionary, but removing agent 4038, as that will result in a runtime error. So will create the trader agents put them in a list and then we will shuffle the list multiple time to prevent mover advantage as dmeonstrated in Ken Comer's seminal dissertation -- [Who Goes First](http://mars.gmu.edu/bitstream/handle/1920/9070/Comer_gmu_0883E_10539.pdf).\n",
        "\n",
        "This may seem a little redundant at first but as we do all the parts of traders you will see why it is important. \n",
        "\n",
        "so first we get just the traders then we put them in a list then we shuffle the list using existing python randomization functions. We then iterate through this list and the move function, which we need to build. \n",
        "\n",
        "\n",
        "\n"
      ],
      "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 \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",
        "      metabolism_sugar = self.random.uniform(self.metabolism_min, self.metabolism_max)\n",
        "      metabolism_spice = self.random.uniform(self.metabolism_min, self.metabolism_max)\n",
        "      #add vision\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): \n",
        "    #part 2\n",
        "    #print(self.schedule.agents_by_type.keys())\n",
        "    #print(self.schedule.agents_by_type[Trader])\n",
        "    \n",
        "    for sugar in self.schedule.agents_by_type[Sugar].values(): \n",
        "      sugar.step()\n",
        "    \n",
        "    for spice in self.schedule.agents_by_type[Spice].values(): \n",
        "      spice.step()\n",
        "    #part 1\n",
        "    Traders = self.schedule.agents_by_type[Trader].values()\n",
        "    Trader_shuffle = list(Traders)\n",
        "    self.random.shuffle(Trader_shuffle)\n",
        "    for agent in Trader_shuffle: \n",
        "      agent.move()  \n",
        "    \n",
        "    self.schedule.time +=1\n",
        "    self.schedule.steps += 1\n",
        "    \n",
        "\n",
        "  \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"
      ],
      "metadata": {
        "id": "kYXO-SNTPnC-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = SugarscapeG1mt()\n",
        "model.run_model(step_count=1) #part 1\n",
        "\n"
      ],
      "metadata": {
        "id": "wbZ1-r5q1fe1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5646c3fc-fd43-4e61-fa2e-7f3660e64ff4"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11 2\n",
            "13 2\n",
            "22 3\n",
            "5 1\n",
            "13 2\n",
            "32 4\n",
            "24 3\n",
            "12 2\n",
            "5 1\n",
            "13 2\n",
            "34 4\n",
            "5 1\n",
            "5 1\n",
            "4 1\n",
            "25 3\n",
            "23 3\n",
            "5 1\n",
            "13 2\n",
            "5 1\n",
            "25 3\n",
            "41 4\n",
            "23 3\n",
            "24 3\n",
            "24 3\n",
            "25 3\n",
            "40 4\n",
            "12 2\n",
            "5 1\n",
            "3 1\n",
            "5 1\n",
            "13 2\n",
            "5 1\n",
            "12 2\n",
            "41 4\n",
            "11 2\n",
            "5 1\n",
            "4 1\n",
            "25 3\n",
            "13 2\n",
            "13 2\n",
            "13 2\n",
            "13 2\n",
            "37 4\n",
            "31 4\n",
            "39 4\n",
            "5 1\n",
            "25 3\n",
            "39 4\n",
            "5 1\n",
            "5 1\n",
            "5 1\n",
            "12 2\n",
            "5 1\n",
            "24 3\n",
            "24 3\n",
            "38 4\n",
            "40 4\n",
            "25 3\n",
            "40 4\n",
            "40 4\n",
            "40 4\n",
            "25 3\n",
            "38 4\n",
            "13 2\n",
            "5 1\n",
            "12 2\n",
            "38 4\n",
            "5 1\n",
            "38 4\n",
            "37 4\n",
            "38 4\n",
            "39 4\n",
            "24 4\n",
            "39 4\n",
            "40 4\n",
            "24 3\n",
            "41 4\n",
            "25 3\n",
            "23 3\n",
            "4 1\n",
            "5 1\n",
            "12 2\n",
            "5 1\n",
            "13 2\n",
            "13 2\n",
            "39 4\n",
            "40 4\n",
            "4 1\n",
            "12 2\n",
            "24 3\n",
            "5 1\n",
            "38 4\n",
            "23 3\n",
            "23 3\n",
            "25 3\n",
            "31 4\n",
            "23 3\n",
            "24 3\n",
            "5 1\n",
            "25 3\n"
          ]
        }
      ]
    }
  ]
}