Ex8.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yy_gJ2K_QlGR"
      },
      "source": [
        "## Basic Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ugp5nutQyQZi",
        "outputId": "b5b3e59c-af88-4ccd-c21b-5875b32271d7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python Version 3.7.13\n",
            "PyTorch Version 1.10.0+cu111\n",
            "Numpy Version 1.21.5\n",
            "Pandas Version 1.3.5\n",
            "Matplotlib Version 3.2.2\n"
          ]
        }
      ],
      "source": [
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "import os\n",
        "import os.path as osp\n",
        "import shutil\n",
        "import sys\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as O\n",
        "import torch.nn.functional as F\n",
        "import torch.utils.data as D\n",
        "\n",
        "\n",
        "from platform import python_version\n",
        "print(\"Python Version\", python_version())\n",
        "print('PyTorch Version', torch.__version__)\n",
        "print(\"Numpy Version\", np.__version__)\n",
        "print(\"Pandas Version\", pd.__version__)\n",
        "print(\"Matplotlib Version\", matplotlib.__version__)\n",
        "\n",
        "pd.set_option('display.max_columns',None)\n",
        "pd.set_option('display.max_rows',None)\n",
        "pd.set_option('display.float_format', lambda x: '%.5f' % x)\n",
        "pd.set_option('display.date_dayfirst', True)\n",
        "pd.set_option('display.max_colwidth', None)\n",
        "\n",
        "# from IPython.core.interactiveshell import InteractiveShell\n",
        "# InteractiveShell.ast_node_interactivity = \"all\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ahwIxwNs0WHg"
      },
      "outputs": [],
      "source": [
        "# Reproduciblity\n",
        "SEED = 1000\n",
        "import random\n",
        "random.seed(SEED)\n",
        "np.random.seed(SEED)\n",
        "torch.manual_seed(SEED)\n",
        "torch.cuda.manual_seed_all(SEED)\n",
        "\n",
        "# Number of Thread\n",
        "NUM_CORES = 20\n",
        "torch.set_num_threads(NUM_CORES)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7EeAcc1d0T9z",
        "outputId": "ded1c00d-5ff0-460d-d940-d64a04bb9587"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GPU not available\n",
            "\n",
            "device = cpu\n"
          ]
        }
      ],
      "source": [
        "# Device to run on\n",
        "DEVICE = 'cuda'\n",
        "if DEVICE=='cuda':\n",
        "    if torch.cuda.is_available():\n",
        "        print('__CUDA VERSION', )\n",
        "        from subprocess import call\n",
        "        !nvcc --version\n",
        "        print('__CUDNN VERSION:', torch.backends.cudnn.version())\n",
        "        print('__Number CUDA Devices:', torch.cuda.device_count())\n",
        "        print('__Devices')\n",
        "        print('Active CUDA Device: GPU', torch.cuda.current_device())\n",
        "        print ('Available devices ', torch.cuda.device_count())\n",
        "        print ('Current cuda device ', torch.cuda.current_device())\n",
        "    else:\n",
        "        print(\"GPU not available\")\n",
        "        DEVICE = 'cpu'\n",
        "\n",
        "print(\"\\ndevice =\", DEVICE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9A0BDLKPQ7dw"
      },
      "source": [
        "## Prepare Environment & Agent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KkuzE0Ma81Cg"
      },
      "outputs": [],
      "source": [
        "def to_node_idx(side_length, x, y):\n",
        "    if x + (side_length*y) < 0:\n",
        "        print(\"ERROR: Node index is negative\")\n",
        "    return x + (side_length*y)\n",
        "\n",
        "def to_coord(side_length, node_idx):\n",
        "    return node_idx % side_length, node_idx // side_length"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YdnJfVT40wY2"
      },
      "outputs": [],
      "source": [
        "class Gridworld:\n",
        "    def __init__(self, side_length=20, agent_init_x=1, agent_init_y=1, num_apples=10, num_poisons=10, num_triggers=1, num_obstacles=0,\n",
        "                 apple_reward=1.0, apple_sd=0.0, poison_reward=-1.0, poison_sd=0.0, prize_reward=5.0, prize_sd=0.0, wall_reward=-0.5, wall_sd=0.0,\n",
        "                 door_reward=10.0, door_sd=0.0, episode_length=6, plot_size=10):\n",
        "    \n",
        "        self.side_length = side_length\n",
        "        self.num_states = self.side_length**2\n",
        "        self.num_obstacles = num_obstacles\n",
        "        self.num_apples = num_apples\n",
        "        self.num_poisons = num_poisons\n",
        "        self.num_triggers = num_triggers\n",
        "        self.init_x = agent_init_x\n",
        "        self.init_y = agent_init_y\n",
        "\n",
        "        self.apple_reward = apple_reward\n",
        "        self.apple_sd = apple_sd\n",
        "        self.poison_reward = poison_reward\n",
        "        self.poison_sd = poison_sd\n",
        "        self.prize_reward = prize_reward\n",
        "        self.prize_sd = prize_sd\n",
        "        self.wall_reward = wall_reward\n",
        "        self.wall_sd = wall_sd\n",
        "        self.door_reward = door_reward\n",
        "        self.door_sd = door_sd\n",
        "\n",
        "        if (side_length-1)**2 < num_apples+num_poisons+num_obstacles+num_triggers+1:\n",
        "            print(\"ERROR: Increase grid size\")\n",
        "        \n",
        "        self.episode_length = episode_length\n",
        "        self.plot_size = plot_size\n",
        "        self.resetEnv()\n",
        "        self.resetTime()\n",
        "\n",
        "\n",
        "    # Reset time\n",
        "    def resetTime(self):\n",
        "        self.agent_x = self.init_x\n",
        "        self.agent_y = self.init_y\n",
        "        self.cum_reward = 0\n",
        "        self.time = 0\n",
        "\n",
        "        self.key_collected = False\n",
        "        for (x,y) in self.triggers_on:\n",
        "            self.triggers_off.add((x,y))\n",
        "        self.triggers_on = set()\n",
        "        for (x,y) in self.apples_dis:\n",
        "            self.apples_vis.add((x,y))\n",
        "        self.apples_dis = set()\n",
        "        for (x,y) in self.poisons_dis:\n",
        "            self.poisons_vis.add((x,y))\n",
        "        self.poisons_dis = set()\n",
        "        self.prize_collected = False\n",
        "        self.door = (self.side_length-1, 1)\n",
        "        if self.door in self.walls:\n",
        "            self.walls.remove(self.door)\n",
        "\n",
        "\n",
        "    # Reset the environment\n",
        "    def resetEnv(self):\n",
        "        self.walls = set([])\n",
        "        for y in range(self.side_length):\n",
        "            self.walls.add((0,y))\n",
        "            self.walls.add((self.side_length-1,y))\n",
        "        for x in range(self.side_length):\n",
        "            self.walls.add((x,0))\n",
        "            self.walls.add((x,self.side_length-1))\n",
        "\n",
        "        self.door = (self.side_length-1, 1)\n",
        "        \n",
        "        self.key_collected = False\n",
        "        self.key = (17, 3)\n",
        "\n",
        "        self.prize = tuple(np.random.randint(low=1, high=self.side_length-1, size=2))\n",
        "        while (self.prize==self.key) or (self.prize==(self.door[0]-1,self.door[1])):\n",
        "            self.prize = tuple(np.random.randint(low=1, high=self.side_length-1, size=2))\n",
        "        self.prize_collected = False\n",
        "        \n",
        "        self.triggers_off = set([])\n",
        "        self.triggers_on = set([])\n",
        "        while len(self.triggers_off) < self.num_triggers:\n",
        "            x = np.random.randint(low=max(1,self.prize[0]-3), \n",
        "                                  high=min(self.side_length-1,self.prize[0]+3))\n",
        "            y = np.random.randint(low=max(1,self.prize[1]-3), \n",
        "                                  high=min(self.side_length-1,self.prize[1]+3))\n",
        "            if ((x,y) not in self.triggers_off) and ((x,y)!=self.key) and ((x,y)!=(self.door[0]-1,self.door[1])) and ((x,y)!=self.prize):\n",
        "                self.triggers_off.add((x,y))\n",
        "        \n",
        "        self.obstacles = set([])\n",
        "        while len(self.obstacles) < self.num_obstacles:\n",
        "            x,y = np.random.randint(low=1, high=self.side_length-1, size=2)\n",
        "            if ((x,y)!=self.key) and ((x,y) not in self.triggers_off) and ((x,y) not in self.obstacles) and (((x,y)!=(self.door[0]-1,self.door[1]))) and ((x,y)!=self.prize):\n",
        "                self.obstacles.add((x,y))\n",
        "\n",
        "        self.apples_vis = set([])\n",
        "        self.apples_dis = set([])\n",
        "        while len(self.apples_vis) < self.num_apples:\n",
        "            x,y = np.random.randint(low=2, high=self.side_length-2, size=2)\n",
        "            if ((x,y)!=self.key) and ((x,y) not in self.triggers_off) and ((x,y) not in self.obstacles) and ((x,y) not in self.apples_vis) and (((x,y)!=(self.door[0]-1,self.door[1]))) and ((x,y)!=self.prize) and (not (x>=14 and y<self.door[1]+5)):\n",
        "                self.apples_vis.add((x,y))\n",
        "        \n",
        "        self.poisons_vis = set([])\n",
        "        self.poisons_dis = set([])\n",
        "        while len(self.poisons_vis) < self.num_poisons:\n",
        "            x,y = np.random.randint(low=2, high=self.side_length-2, size=2)\n",
        "            if ((x,y)!=self.key) and ((x,y) not in self.triggers_off) and ((x,y) not in self.obstacles) and ((x,y) not in self.apples_vis) and ((x,y) not in self.poisons_vis) and (((x,y)!=(self.door[0]-1,self.door[1]))) and ((x,y)!=self.prize) and (not (x>=14 and y<self.door[1]+5)):\n",
        "                self.poisons_vis.add((x,y))\n",
        "        \n",
        "        \n",
        "        self.walls.remove(self.door)\n",
        "\n",
        "        if (self.init_x,self.init_y) in self.walls:\n",
        "            print(\"ERROR: Agent initialised inside wall at (\", self.init_x, \",\", self.init_y, \")\", sep=\"\")\n",
        "\n",
        "\n",
        "    # Accept an agent's action, return new state and reward\n",
        "    # 0 = Up, 1 = Up-Right, 2 = Right, 3 = Down-Right, 4 = Down, 5 = Down-Left, 6 = Left, 7 = Up-Left\n",
        "    def step(self, action):\n",
        "        if self.time>=self.episode_length:\n",
        "            return None, None\n",
        "        self.time += 1\n",
        "        new_x,new_y = self.agent_x,self.agent_y\n",
        "        if action==0:\n",
        "            new_y += 1\n",
        "        elif action==1:\n",
        "            new_x += 1\n",
        "            new_y += 1\n",
        "        elif action==2:\n",
        "            new_x += 1\n",
        "        elif action==3:\n",
        "            new_x += 1\n",
        "            new_y -= 1\n",
        "        elif action==4:\n",
        "            new_y -= 1\n",
        "        elif action==5:\n",
        "            new_x -= 1\n",
        "            new_y -= 1\n",
        "        elif action==6:\n",
        "            new_x -= 1\n",
        "        else:\n",
        "            new_x -= 1\n",
        "            new_y += 1\n",
        "        if (new_x,new_y)==self.key:\n",
        "            self.key_collected = True\n",
        "        if (new_x,new_y) in self.triggers_off:\n",
        "            self.triggers_on.add((new_x,new_y))\n",
        "            self.triggers_off.remove((new_x,new_y))\n",
        "        if (new_x,new_y) in self.poisons_vis:\n",
        "            self.cum_reward += self.poison_reward+np.random.normal(loc=0.0, scale=self.poison_sd)\n",
        "            self.poisons_vis.remove((new_x,new_y))\n",
        "            self.poisons_dis.add((new_x,new_y))\n",
        "        if (new_x,new_y) in self.apples_vis:\n",
        "            self.cum_reward += self.apple_reward+np.random.normal(loc=0.0, scale=self.apple_sd)\n",
        "            self.apples_vis.remove((new_x,new_y))\n",
        "            self.apples_dis.add((new_x,new_y))\n",
        "        if self.prize_collected==False and ((new_x,new_y)==self.prize):\n",
        "            if len(self.triggers_on)==self.num_triggers:\n",
        "                self.cum_reward += self.prize_reward+np.random.normal(loc=0.0, scale=self.prize_sd)\n",
        "                self.prize_collected = True\n",
        "        if (new_x,new_y)==self.door:\n",
        "            r = self.door_reward + np.random.normal(loc=0.0, scale=self.door_sd)\n",
        "            if self.key_collected:\n",
        "                self.cum_reward += r\n",
        "            self.walls.add(self.door)\n",
        "            self.door = (-1,-1)\n",
        "        elif ((new_x,new_y) in self.walls) or ((new_x,new_y) in self.obstacles):\n",
        "            self.cum_reward += self.wall_reward+np.random.normal(loc=0.0, scale=self.wall_sd)\n",
        "        else:\n",
        "            if new_x<0 or new_y<0 or new_x>=self.side_length or new_y>=self.side_length:\n",
        "                print(\"ERROR: Agent about to go out of grid from (\", self.agent_x, \",\", self.agent_y, \") to (\", new_x, \",\", new_y, \")\", sep='')\n",
        "                return None, None\n",
        "            self.agent_x,self.agent_y = new_x,new_y\n",
        "\n",
        "        r = 0\n",
        "        if self.time>=self.episode_length:\n",
        "            r = self.cum_reward\n",
        "        return (self.agent_x,self.agent_y), r\n",
        "\n",
        "\n",
        "    # Return the grid\n",
        "    def getGrid(self):\n",
        "        grid = []\n",
        "        for r in range(self.side_length):\n",
        "            row = []\n",
        "            for c in range(self.side_length):\n",
        "                x,y = c,r\n",
        "                if (x,y)==(self.side_length-1, 1): # door\n",
        "                    row.append(0.7)\n",
        "                elif ((x,y) in self.walls) or ((x,y) in self.obstacles):\n",
        "                    row.append(0.0)\n",
        "                elif (x,y)==self.key:\n",
        "                    row.append(0.5)\n",
        "                elif ((x,y) in self.triggers_off) or ((x,y) in self.triggers_on):\n",
        "                    row.append(0.6)\n",
        "                elif ((x,y) in self.apples_vis) or ((x,y) in self.apples_dis):\n",
        "                    row.append(0.3)\n",
        "                elif ((x,y) in self.poisons_vis) or ((x,y) in self.poisons_dis):\n",
        "                    row.append(0.2)\n",
        "                elif (x,y)==self.prize:\n",
        "                    row.append(0.4)\n",
        "                else:\n",
        "                    row.append(0.1)\n",
        "            grid.append(row)\n",
        "        return grid\n",
        "\n",
        "\n",
        "    # Plot the grid\n",
        "    def plotGrid(self,grid):\n",
        "        cm = matplotlib.colors.ListedColormap(['black', 'white', 'blue', 'red', 'green', 'gold', 'lawngreen', 'grey', 'aqua', 'pink', 'brown'])\n",
        "        plt.figure(figsize=(self.plot_size,self.plot_size))\n",
        "        plt.pcolormesh(grid, edgecolors='black', cmap=cm, vmin=0.0, vmax=1.0)\n",
        "        plt.axes().set_aspect('equal')\n",
        "        plt.xticks([])\n",
        "        plt.yticks([])\n",
        "        # plt.axes().invert_yaxis()\n",
        "        plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 578
        },
        "id": "_XkJV62OGP39",
        "outputId": "a57da0c0-45db-4eeb-d769-455248ac4bbc"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "env = Gridworld()\n",
        "env.plotGrid(env.getGrid())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3wetsrCB7vpo"
      },
      "outputs": [],
      "source": [
        "class Agent:\n",
        "    def __init__(self, num_states, num_actions=8, init_state=(1,1), buffer_limit=np.inf):\n",
        "        self.init_state = init_state\n",
        "        self.num_states = num_states\n",
        "        self.num_actions = num_actions\n",
        "        self.buffer_limit = buffer_limit\n",
        "\n",
        "        self.reset()\n",
        "        self.resetBuffer()\n",
        "        self.initializePolicy()\n",
        "    \n",
        "\n",
        "    def reset(self):\n",
        "        self.curr_exp = [[], [], []]\n",
        "        self.state = self.init_state\n",
        "\n",
        "\n",
        "    def resetBuffer(self):\n",
        "        self.experience = [[], [], []]\n",
        "\n",
        "\n",
        "    def initializePolicy(self):\n",
        "        self.policy = {}\n",
        "        random_actions = [1.0/float(self.num_actions) for a in range(self.num_actions)]\n",
        "        for s in range(self.num_states):\n",
        "            self.policy[s] = random_actions\n",
        "\n",
        "    def playEpisode(self, env):\n",
        "        state = to_node_idx(env.side_length, self.state[0], self.state[1])\n",
        "        actions = [i for i in range(self.num_actions)]\n",
        "\n",
        "        self.curr_exp[0].append(state)\n",
        "        while True:\n",
        "            a = np.random.choice(a=actions, p=self.policy[state])\n",
        "            self.state, r = env.step(a)\n",
        "            # print(\"self.state =\", self.state, \" r =\", r)\n",
        "            if self.state==None or r==None:\n",
        "                # self.curr_exp[0].pop()\n",
        "                break\n",
        "            self.curr_exp[1].append(a)\n",
        "            self.curr_exp[2].append(r)\n",
        "            state = to_node_idx(env.side_length, self.state[0], self.state[1])\n",
        "            self.curr_exp[0].append(state)\n",
        "        \n",
        "        self.storeExperience()\n",
        "        return self.curr_exp\n",
        "\n",
        "\n",
        "    # Return an episode as 3 lists and episode index\n",
        "    def sampleEpisode(self):\n",
        "        if len(self.experience[0])==0:\n",
        "            print(\"ERROR: Agent has no experience\")\n",
        "            return None, None, None, None\n",
        "\n",
        "        episode_idx = np.random.randint(0,len(self.experience[0]))\n",
        "        return self.experience[0][episode_idx], self.experience[1][episode_idx], self.experience[2][episode_idx], episode_idx\n",
        "\n",
        "\n",
        "    # Store current experience in buffer\n",
        "    def storeExperience(self):\n",
        "        while len(self.experience[0]) >= self.buffer_limit:\n",
        "            self.experience[0] = self.experience[0][1:]\n",
        "            self.experience[1] = self.experience[1][1:]\n",
        "            self.experience[2] = self.experience[2][1:]\n",
        "\n",
        "        self.experience[0].append(self.curr_exp[0])\n",
        "        self.experience[1].append(self.curr_exp[1])\n",
        "        self.experience[2].append(self.curr_exp[2])\n",
        "\n",
        "agent = Agent(env.side_length**2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qK749LzIVfd9"
      },
      "source": [
        "## Prepare traning pipleline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pGMZ5PrNViTF"
      },
      "outputs": [],
      "source": [
        "def getLoss(pred, ground):\n",
        "    pred = torch.sum(pred, dim=1)\n",
        "    ground = torch.sum(ground, dim=1)\n",
        "    t = torch.mean(torch.square(pred - ground))\n",
        "    return t"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6XCbps7rUhJq"
      },
      "source": [
        "## Setup & Train MLP"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OZlrESmIUm8K"
      },
      "outputs": [],
      "source": [
        "class MLP(torch.nn.Module):\n",
        "    def __init__ (self, num_states, hidden_size, out_size):\n",
        "        super(MLP, self).__init__()\n",
        "        self.lin1 = torch.nn.Linear(in_features=num_states, out_features=hidden_size, bias=True)\n",
        "        self.lin2 = torch.nn.Linear(in_features=hidden_size, out_features=1, bias=True)\n",
        "        self.num_states = num_states\n",
        "\n",
        "    def forward(self, s):\n",
        "        X = torch.nn.functional.one_hot(s, num_classes=self.num_states)\n",
        "        X = X.type(torch.FloatTensor)\n",
        "        X = torch.tanh(self.lin1(X))\n",
        "        X = self.lin2(X)\n",
        "        return X\n",
        "\n",
        "\n",
        "MLPmodel = MLP(env.side_length**2, 64, 4).to(DEVICE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LrFLbWX9VP3O"
      },
      "outputs": [],
      "source": [
        "INIT_LR = 0.1\n",
        "optimizer = torch.optim.Adam(MLPmodel.parameters(), lr=INIT_LR, betas=(0.9, 0.98), eps=1e-9, weight_decay=0, amsgrad=False)\n",
        "\n",
        "def checkpoint():\n",
        "    torch.save(MLPmodel.state_dict(), \"MLPmodel.pt\")\n",
        "    print(\"Model checkpointed!\")\n",
        "\n",
        "# Multiply LR by factor if loss has not decayed by threshold for patience epochs\n",
        "platLR = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, threshold=1e-4, \n",
        "                                                    threshold_mode='abs', cooldown=1, min_lr=0, eps=1e-12, verbose=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GHbg7k2kWJ0Q",
        "outputId": "8d72c30e-2013-4f46-e476-7c37c96b9c62"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting to train MLP...\n",
            "\n",
            "iter : 1 | loss : 1.00637\n",
            "iter : 2 | loss : 3.113548\n",
            "Model checkpointed!\n",
            "iter : 3 | loss : 6.441756\n",
            "iter : 4 | loss : 6.874921\n",
            "iter : 5 | loss : 6.275825\n",
            "iter : 6 | loss : 5.88677\n",
            "iter : 7 | loss : 5.451464\n",
            "iter : 8 | loss : 5.01561\n",
            "iter : 9 | loss : 5.119448\n",
            "iter : 10 | loss : 5.136279\n",
            "iter : 11 | loss : 4.704579\n",
            "iter : 12 | loss : 4.664455\n",
            "iter : 13 | loss : 4.647904\n",
            "iter : 14 | loss : 4.264029\n",
            "iter : 15 | loss : 4.178058\n",
            "iter : 16 | loss : 4.148561\n",
            "iter : 17 | loss : 3.799408\n",
            "iter : 18 | loss : 3.737111\n",
            "iter : 19 | loss : 3.650368\n",
            "iter : 20 | loss : 3.35189\n",
            "iter : 21 | loss : 3.202121\n",
            "iter : 22 | loss : 3.127645\n",
            "iter : 23 | loss : 2.874242\n",
            "Model checkpointed!\n",
            "iter : 24 | loss : 2.699863\n",
            "Model checkpointed!\n",
            "iter : 25 | loss : 2.660719\n",
            "Model checkpointed!\n",
            "iter : 26 | loss : 2.482832\n",
            "Model checkpointed!\n",
            "iter : 27 | loss : 2.293669\n",
            "Model checkpointed!\n",
            "iter : 28 | loss : 2.179226\n",
            "Model checkpointed!\n",
            "iter : 29 | loss : 2.07114\n",
            "Model checkpointed!\n",
            "iter : 30 | loss : 1.906619\n",
            "Model checkpointed!\n",
            "iter : 31 | loss : 1.770754\n",
            "Model checkpointed!\n",
            "iter : 32 | loss : 1.682323\n",
            "Model checkpointed!\n",
            "iter : 33 | loss : 1.627787\n",
            "Model checkpointed!\n",
            "iter : 34 | loss : 1.497043\n",
            "Model checkpointed!\n",
            "iter : 35 | loss : 1.390528\n",
            "Model checkpointed!\n",
            "iter : 36 | loss : 1.342026\n",
            "Model checkpointed!\n",
            "iter : 37 | loss : 1.268149\n",
            "Model checkpointed!\n",
            "iter : 38 | loss : 1.175211\n",
            "Model checkpointed!\n",
            "iter : 39 | loss : 1.099791\n",
            "Model checkpointed!\n",
            "iter : 40 | loss : 1.049877\n",
            "Model checkpointed!\n",
            "iter : 41 | loss : 0.990511\n",
            "Model checkpointed!\n",
            "iter : 42 | loss : 0.947647\n",
            "Model checkpointed!\n",
            "iter : 43 | loss : 0.868805\n",
            "Model checkpointed!\n",
            "iter : 44 | loss : 0.820632\n",
            "Model checkpointed!\n",
            "iter : 45 | loss : 0.784276\n",
            "Model checkpointed!\n",
            "iter : 46 | loss : 0.737727\n",
            "Model checkpointed!\n",
            "iter : 47 | loss : 0.689333\n",
            "Model checkpointed!\n",
            "iter : 48 | loss : 0.64705\n",
            "Model checkpointed!\n",
            "iter : 49 | loss : 0.636901\n",
            "Model checkpointed!\n",
            "iter : 50 | loss : 0.629346\n",
            "Model checkpointed!\n",
            "iter : 51 | loss : 0.582381\n",
            "Model checkpointed!\n",
            "iter : 52 | loss : 0.563375\n",
            "Model checkpointed!\n",
            "iter : 53 | loss : 0.534525\n",
            "Model checkpointed!\n",
            "iter : 54 | loss : 0.508824\n",
            "Model checkpointed!\n",
            "iter : 55 | loss : 0.482529\n",
            "Model checkpointed!\n",
            "iter : 56 | loss : 0.460487\n",
            "Model checkpointed!\n",
            "iter : 57 | loss : 0.432433\n",
            "Model checkpointed!\n",
            "iter : 58 | loss : 0.409517\n",
            "Model checkpointed!\n",
            "iter : 59 | loss : 0.383654\n",
            "Model checkpointed!\n",
            "iter : 60 | loss : 0.361019\n",
            "Model checkpointed!\n",
            "iter : 61 | loss : 0.339441\n",
            "Model checkpointed!\n",
            "iter : 62 | loss : 0.389428\n",
            "iter : 63 | loss : 0.364984\n",
            "iter : 64 | loss : 0.342803\n",
            "iter : 65 | loss : 0.322217\n",
            "Model checkpointed!\n",
            "iter : 66 | loss : 0.332869\n",
            "iter : 67 | loss : 0.376566\n",
            "iter : 68 | loss : 0.356971\n",
            "iter : 69 | loss : 0.339277\n",
            "iter : 70 | loss : 0.319569\n",
            "Model checkpointed!\n",
            "iter : 71 | loss : 0.300639\n",
            "Model checkpointed!\n",
            "iter : 72 | loss : 0.281586\n",
            "Model checkpointed!\n",
            "iter : 73 | loss : 0.30519\n",
            "iter : 74 | loss : 0.288825\n",
            "iter : 75 | loss : 0.274454\n",
            "Model checkpointed!\n",
            "iter : 76 | loss : 0.28973\n",
            "iter : 77 | loss : 0.272615\n",
            "Model checkpointed!\n",
            "iter : 78 | loss : 0.26563\n",
            "Model checkpointed!\n",
            "iter : 79 | loss : 0.251182\n",
            "Model checkpointed!\n",
            "iter : 80 | loss : 0.238453\n",
            "Model checkpointed!\n"
          ]
        }
      ],
      "source": [
        "print(\"Starting to train MLP...\\n\")\n",
        "NUM_ITER = 80\n",
        "\n",
        "best_loss = np.inf\n",
        "MLPlosses = []\n",
        "MLPmodel.train()\n",
        "GAMMA = 0.1\n",
        "\n",
        "for iter in range(1, NUM_ITER+1):\n",
        "    agent.resetBuffer()\n",
        "\n",
        "    for x in range(1,env.side_length-1):\n",
        "        for y in range(1,env.side_length-1):\n",
        "            if (x,y) in env.obstacles:\n",
        "                continue \n",
        "            env.init_x,env.init_y = x,y\n",
        "            agent.init_state = (x,y)\n",
        "            agent.reset()\n",
        "            env.resetTime()\n",
        "            ep = agent.playEpisode(env)\n",
        "\n",
        "    states = torch.tensor(agent.experience[0]).to(DEVICE)\n",
        "    actions = torch.tensor(agent.experience[1]).to(DEVICE)\n",
        "    rewards = torch.tensor(agent.experience[2]).to(DEVICE)\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    pred = MLPmodel(states)\n",
        "\n",
        "    pred = pred.reshape((pred.size(0),pred.size(1)))\n",
        "    pred = pred[:,1:]\n",
        "    loss = getLoss(pred, rewards)\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    platLR.step(loss)\n",
        "    if len(MLPlosses)>0:\n",
        "        L = (GAMMA*float(loss)) + ((1.0-GAMMA)*MLPlosses[-1])\n",
        "    else:\n",
        "        L = float(loss)\n",
        "    MLPlosses.append(L)\n",
        "            \n",
        "    print(\"iter : \"+str(iter)+\" | loss : \"+str(np.around(MLPlosses[-1], 6)))\n",
        "    if iter>1 and best_loss > MLPlosses[-1]:\n",
        "        checkpoint()\n",
        "        best_loss = MLPlosses[-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXifZjF9YVzu"
      },
      "source": [
        "## Plots"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MxElGJ4HXj6i",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 513
        },
        "outputId": "64169674-96ee-4049-e913-c544af7ad3cd"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plt.figure(figsize=(8,8))\n",
        "plt.plot([i for i in range(len(MLPlosses))], MLPlosses)\n",
        "plt.title(\"Losses vs Iteration\")\n",
        "plt.xlabel('iteration')\n",
        "plt.ylabel('loss')\n",
        "plt.grid()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oZb519bXg_tH"
      },
      "outputs": [],
      "source": [
        "MLPmodel.eval()\n",
        "def getAllRewards(model = MLPmodel):\n",
        "    s = torch.arange(start=0, end=env.side_length**2, step=1, dtype=torch.long, device=DEVICE)\n",
        "    # print(\"s.size =\", s.size())\n",
        "    s = s.reshape((1,s.size(0)))\n",
        "    # print(\"s.size =\", s.size())\n",
        "    r = model.forward(s)\n",
        "    return r\n",
        "\n",
        "\n",
        "def plotStates(grid, rewards, softmax=True):\n",
        "    matrix = np.array([[float(rewards[to_node_idx(env.side_length, i,j)].cpu().detach().numpy()) for i in range(1,env.side_length-1)] for j in range(1,env.side_length-1)])\n",
        "    cm = sns.light_palette(\"blue\", as_cmap=True)\n",
        "    x = pd.DataFrame(matrix).iloc[::-1]\n",
        "    x = x.style.background_gradient(cmap=cm, axis=None)\n",
        "    display(x)\n",
        "    return x\n",
        "\n",
        "\n",
        "def plotStatesSmall(c):\n",
        "    color_list = list(c.ctx.values())\n",
        "    color_list = sorted([str(key[0][1]) for key in color_list])\n",
        "    color_list.append('black')\n",
        "    cm = matplotlib.colors.ListedColormap(color_list)\n",
        "    color2idx = {}\n",
        "    for i,color in enumerate(color_list):\n",
        "        color2idx[color] = i\n",
        "\n",
        "    grad_plot = [[max(color2idx.values())+1 for i in range(env.side_length)] for j in range(env.side_length)]\n",
        "    data = [[0.0 for i in range(env.side_length)] for j in range(env.side_length)]\n",
        "    for key in c.ctx.keys():\n",
        "        x = int(key[0])+1\n",
        "        y = int(key[1])+1\n",
        "        if (y,env.side_length-1-x) in env.obstacles:\n",
        "            continue \n",
        "        color = str(c.ctx[key][0][1])\n",
        "        grad_plot[x][y] = color2idx[color]\n",
        "\n",
        "    plt.figure(figsize=(env.plot_size,env.plot_size))\n",
        "    plt.pcolormesh(grad_plot, edgecolors='black', cmap=cm, vmin=min(color2idx.values()), vmax=max(color2idx.values())+1)\n",
        "    plt.axes().set_aspect('equal')\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    plt.axes().invert_yaxis()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UcIA-x8P82EC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "45dd9248-653b-4faf-a434-a9724e89eeb8"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<pandas.io.formats.style.Styler at 0x7fc263d9ebd0>"
            ],
            "text/html": [
              "<style type=\"text/css\">\n",
              "#T_a77b3_row0_col0 {\n",
              "  background-color: #b8b8f6;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row0_col1 {\n",
              "  background-color: #8c8cf8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col2, #T_a77b3_row0_col14, #T_a77b3_row10_col0 {\n",
              "  background-color: #9b9bf7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col3, #T_a77b3_row5_col0, #T_a77b3_row13_col17, #T_a77b3_row17_col2 {\n",
              "  background-color: #9e9ef7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col4 {\n",
              "  background-color: #a2a2f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col5, #T_a77b3_row7_col0, #T_a77b3_row12_col17, #T_a77b3_row17_col6 {\n",
              "  background-color: #9c9cf7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col6, #T_a77b3_row0_col12, #T_a77b3_row1_col17, #T_a77b3_row3_col17, #T_a77b3_row17_col11, #T_a77b3_row17_col12 {\n",
              "  background-color: #9a9af7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col7, #T_a77b3_row2_col17, #T_a77b3_row17_col8, #T_a77b3_row17_col16 {\n",
              "  background-color: #a1a1f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col8, #T_a77b3_row13_col0 {\n",
              "  background-color: #9f9ff7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col9, #T_a77b3_row9_col17 {\n",
              "  background-color: #9595f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col10, #T_a77b3_row14_col0, #T_a77b3_row17_col3 {\n",
              "  background-color: #a0a0f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col11, #T_a77b3_row2_col0, #T_a77b3_row11_col17, #T_a77b3_row17_col4, #T_a77b3_row17_col5, #T_a77b3_row17_col9, #T_a77b3_row17_col13 {\n",
              "  background-color: #9d9df7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col13 {\n",
              "  background-color: #9292f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col15, #T_a77b3_row1_col0, #T_a77b3_row4_col17, #T_a77b3_row6_col0, #T_a77b3_row7_col17, #T_a77b3_row17_col10 {\n",
              "  background-color: #9494f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col16, #T_a77b3_row17_col15 {\n",
              "  background-color: #9999f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row0_col17 {\n",
              "  background-color: #b5b5f6;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row1_col1, #T_a77b3_row1_col7, #T_a77b3_row1_col15, #T_a77b3_row7_col12, #T_a77b3_row16_col3 {\n",
              "  background-color: #6565fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col2, #T_a77b3_row2_col1, #T_a77b3_row13_col9, #T_a77b3_row15_col13 {\n",
              "  background-color: #6c6cf9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col3, #T_a77b3_row5_col12, #T_a77b3_row6_col10, #T_a77b3_row8_col4, #T_a77b3_row8_col9, #T_a77b3_row15_col2 {\n",
              "  background-color: #6868fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col4, #T_a77b3_row10_col4, #T_a77b3_row14_col12 {\n",
              "  background-color: #6666fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col5, #T_a77b3_row8_col16 {\n",
              "  background-color: #5f5ffa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col6, #T_a77b3_row3_col12, #T_a77b3_row8_col13, #T_a77b3_row9_col11, #T_a77b3_row12_col5, #T_a77b3_row16_col5 {\n",
              "  background-color: #7070f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col8, #T_a77b3_row4_col13 {\n",
              "  background-color: #6060fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col9, #T_a77b3_row1_col10, #T_a77b3_row2_col9, #T_a77b3_row3_col13, #T_a77b3_row5_col8, #T_a77b3_row6_col3, #T_a77b3_row6_col9, #T_a77b3_row7_col1, #T_a77b3_row7_col3, #T_a77b3_row7_col7, #T_a77b3_row10_col15, #T_a77b3_row11_col8, #T_a77b3_row13_col1, #T_a77b3_row13_col4, #T_a77b3_row14_col6, #T_a77b3_row14_col13, #T_a77b3_row15_col9 {\n",
              "  background-color: #6f6ff9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col11, #T_a77b3_row2_col2, #T_a77b3_row3_col1, #T_a77b3_row3_col5, #T_a77b3_row5_col6, #T_a77b3_row6_col15, #T_a77b3_row8_col5, #T_a77b3_row8_col14, #T_a77b3_row9_col3, #T_a77b3_row9_col12, #T_a77b3_row12_col9, #T_a77b3_row13_col7, #T_a77b3_row14_col10, #T_a77b3_row15_col8, #T_a77b3_row16_col14 {\n",
              "  background-color: #6b6bfa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col12, #T_a77b3_row1_col16, #T_a77b3_row3_col6, #T_a77b3_row6_col1, #T_a77b3_row8_col11, #T_a77b3_row9_col9, #T_a77b3_row16_col1 {\n",
              "  background-color: #6969fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col13 {\n",
              "  background-color: #5e5efa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row1_col14 {\n",
              "  background-color: #0808ff;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col3, #T_a77b3_row2_col6, #T_a77b3_row2_col10, #T_a77b3_row4_col8, #T_a77b3_row7_col6, #T_a77b3_row9_col10, #T_a77b3_row14_col7 {\n",
              "  background-color: #7676f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col4, #T_a77b3_row2_col11, #T_a77b3_row4_col9, #T_a77b3_row5_col3, #T_a77b3_row6_col7, #T_a77b3_row7_col11, #T_a77b3_row9_col6, #T_a77b3_row9_col15, #T_a77b3_row10_col6, #T_a77b3_row11_col1, #T_a77b3_row12_col8, #T_a77b3_row13_col2, #T_a77b3_row14_col15, #T_a77b3_row16_col2 {\n",
              "  background-color: #7575f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col5, #T_a77b3_row3_col2, #T_a77b3_row4_col1, #T_a77b3_row5_col10, #T_a77b3_row10_col5, #T_a77b3_row10_col7, #T_a77b3_row13_col15, #T_a77b3_row15_col4, #T_a77b3_row15_col14, #T_a77b3_row16_col4 {\n",
              "  background-color: #6e6ef9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col7 {\n",
              "  background-color: #8080f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col8, #T_a77b3_row4_col2, #T_a77b3_row4_col7, #T_a77b3_row4_col14, #T_a77b3_row4_col16, #T_a77b3_row5_col4, #T_a77b3_row7_col2, #T_a77b3_row8_col1, #T_a77b3_row11_col4, #T_a77b3_row11_col9, #T_a77b3_row13_col3, #T_a77b3_row13_col5, #T_a77b3_row16_col7, #T_a77b3_row16_col12 {\n",
              "  background-color: #7171f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col12, #T_a77b3_row11_col2 {\n",
              "  background-color: #8585f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col13, #T_a77b3_row6_col8, #T_a77b3_row15_col12 {\n",
              "  background-color: #6363fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col14, #T_a77b3_row4_col4, #T_a77b3_row5_col9, #T_a77b3_row7_col8, #T_a77b3_row10_col1, #T_a77b3_row10_col12, #T_a77b3_row11_col11 {\n",
              "  background-color: #7878f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row2_col15, #T_a77b3_row12_col1 {\n",
              "  background-color: #d2d2f4;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row2_col16, #T_a77b3_row5_col15, #T_a77b3_row6_col6, #T_a77b3_row8_col8, #T_a77b3_row8_col12, #T_a77b3_row14_col14 {\n",
              "  background-color: #7b7bf9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col0 {\n",
              "  background-color: #a5a5f7;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row3_col3, #T_a77b3_row3_col15, #T_a77b3_row4_col10, #T_a77b3_row6_col16, #T_a77b3_row9_col7, #T_a77b3_row10_col16, #T_a77b3_row11_col10, #T_a77b3_row12_col12, #T_a77b3_row13_col14, #T_a77b3_row14_col3 {\n",
              "  background-color: #7373f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col4, #T_a77b3_row3_col7 {\n",
              "  background-color: #6d6df9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col8, #T_a77b3_row4_col6, #T_a77b3_row5_col14, #T_a77b3_row10_col2, #T_a77b3_row10_col11, #T_a77b3_row12_col14, #T_a77b3_row13_col10, #T_a77b3_row14_col11, #T_a77b3_row15_col5, #T_a77b3_row16_col13 {\n",
              "  background-color: #7979f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col9, #T_a77b3_row6_col2, #T_a77b3_row9_col16, #T_a77b3_row14_col4, #T_a77b3_row16_col15 {\n",
              "  background-color: #6464fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col10 {\n",
              "  background-color: #0d0dfe;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col11 {\n",
              "  background-color: #5d5dfa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col14, #T_a77b3_row17_col7 {\n",
              "  background-color: #8787f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row3_col16, #T_a77b3_row4_col3, #T_a77b3_row6_col5, #T_a77b3_row9_col8, #T_a77b3_row13_col16, #T_a77b3_row15_col3, #T_a77b3_row15_col15 {\n",
              "  background-color: #7a7af9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row4_col0 {\n",
              "  background-color: #8f8ff8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row4_col5 {\n",
              "  background-color: #0f0ffe;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row4_col11, #T_a77b3_row4_col12, #T_a77b3_row7_col10, #T_a77b3_row8_col3, #T_a77b3_row9_col2, #T_a77b3_row9_col13, #T_a77b3_row10_col8, #T_a77b3_row11_col7, #T_a77b3_row12_col16, #T_a77b3_row13_col13, #T_a77b3_row15_col11 {\n",
              "  background-color: #7272f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row4_col15 {\n",
              "  background-color: #f0f0f3;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row5_col1, #T_a77b3_row6_col4, #T_a77b3_row8_col6, #T_a77b3_row8_col15, #T_a77b3_row9_col5, #T_a77b3_row11_col6, #T_a77b3_row11_col15, #T_a77b3_row13_col8, #T_a77b3_row13_col11, #T_a77b3_row14_col1 {\n",
              "  background-color: #7777f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row5_col2, #T_a77b3_row7_col14 {\n",
              "  background-color: #7474f9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row5_col5 {\n",
              "  background-color: #d5d5f4;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row5_col7, #T_a77b3_row6_col13, #T_a77b3_row8_col10, #T_a77b3_row10_col9, #T_a77b3_row10_col14, #T_a77b3_row11_col16, #T_a77b3_row12_col3 {\n",
              "  background-color: #7c7cf9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row5_col11, #T_a77b3_row8_col2, #T_a77b3_row11_col5, #T_a77b3_row16_col9, #T_a77b3_row16_col11 {\n",
              "  background-color: #7d7df9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row5_col13 {\n",
              "  background-color: #0c0cfe;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row5_col16, #T_a77b3_row9_col14, #T_a77b3_row12_col7, #T_a77b3_row13_col6 {\n",
              "  background-color: #6a6afa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row5_col17 {\n",
              "  background-color: #8484f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row6_col11, #T_a77b3_row14_col5 {\n",
              "  background-color: #0a0afe;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row6_col12, #T_a77b3_row15_col10 {\n",
              "  background-color: #6161fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row6_col14 {\n",
              "  background-color: #d4d4f4;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row6_col17, #T_a77b3_row14_col17 {\n",
              "  background-color: #a4a4f7;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row7_col4, #T_a77b3_row10_col3, #T_a77b3_row11_col12, #T_a77b3_row14_col8 {\n",
              "  background-color: #8282f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row7_col5, #T_a77b3_row10_col10, #T_a77b3_row14_col16, #T_a77b3_row16_col10 {\n",
              "  background-color: #6767fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row7_col9 {\n",
              "  background-color: #0000ff;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row7_col13 {\n",
              "  background-color: #8686f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row7_col15, #T_a77b3_row12_col10 {\n",
              "  background-color: #0404ff;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row7_col16, #T_a77b3_row8_col7, #T_a77b3_row9_col1, #T_a77b3_row16_col6 {\n",
              "  background-color: #6262fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row8_col0 {\n",
              "  background-color: #9898f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row8_col17 {\n",
              "  background-color: #afaff6;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row9_col0 {\n",
              "  background-color: #9090f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row9_col4, #T_a77b3_row13_col12 {\n",
              "  background-color: #8383f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row10_col13 {\n",
              "  background-color: #7f7ff9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row10_col17 {\n",
              "  background-color: #9191f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row11_col0 {\n",
              "  background-color: #8a8af8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row11_col3 {\n",
              "  background-color: #d7d7f4;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row11_col13, #T_a77b3_row11_col14 {\n",
              "  background-color: #e8e8f3;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row12_col0 {\n",
              "  background-color: #ababf6;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row12_col2, #T_a77b3_row12_col4, #T_a77b3_row12_col13 {\n",
              "  background-color: #8181f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row12_col6, #T_a77b3_row14_col2 {\n",
              "  background-color: #7e7ef9;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row12_col11 {\n",
              "  background-color: #d8d8f4;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row12_col15 {\n",
              "  background-color: #e1e1f4;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row14_col9 {\n",
              "  background-color: #0707ff;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row15_col0 {\n",
              "  background-color: #9696f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row15_col1 {\n",
              "  background-color: #5959fa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row15_col6 {\n",
              "  background-color: #5b5bfa;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row15_col7 {\n",
              "  background-color: #3a3afc;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row15_col16 {\n",
              "  background-color: #4d4dfb;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row15_col17 {\n",
              "  background-color: #aaaaf6;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row16_col0 {\n",
              "  background-color: #a3a3f7;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row16_col8 {\n",
              "  background-color: #5151fb;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row16_col16 {\n",
              "  background-color: #5656fb;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row16_col17 {\n",
              "  background-color: #5050fb;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row17_col0 {\n",
              "  background-color: #b6b6f6;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row17_col1 {\n",
              "  background-color: #8888f8;\n",
              "  color: #f1f1f1;\n",
              "}\n",
              "#T_a77b3_row17_col14 {\n",
              "  background-color: #b1b1f6;\n",
              "  color: #000000;\n",
              "}\n",
              "#T_a77b3_row17_col17 {\n",
              "  background-color: #adadf6;\n",
              "  color: #000000;\n",
              "}\n",
              "</style>\n",
              "<table id=\"T_a77b3_\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th class=\"blank level0\" >&nbsp;</th>\n",
              "      <th class=\"col_heading level0 col0\" >0</th>\n",
              "      <th class=\"col_heading level0 col1\" >1</th>\n",
              "      <th class=\"col_heading level0 col2\" >2</th>\n",
              "      <th class=\"col_heading level0 col3\" >3</th>\n",
              "      <th class=\"col_heading level0 col4\" >4</th>\n",
              "      <th class=\"col_heading level0 col5\" >5</th>\n",
              "      <th class=\"col_heading level0 col6\" >6</th>\n",
              "      <th class=\"col_heading level0 col7\" >7</th>\n",
              "      <th class=\"col_heading level0 col8\" >8</th>\n",
              "      <th class=\"col_heading level0 col9\" >9</th>\n",
              "      <th class=\"col_heading level0 col10\" >10</th>\n",
              "      <th class=\"col_heading level0 col11\" >11</th>\n",
              "      <th class=\"col_heading level0 col12\" >12</th>\n",
              "      <th class=\"col_heading level0 col13\" >13</th>\n",
              "      <th class=\"col_heading level0 col14\" >14</th>\n",
              "      <th class=\"col_heading level0 col15\" >15</th>\n",
              "      <th class=\"col_heading level0 col16\" >16</th>\n",
              "      <th class=\"col_heading level0 col17\" >17</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row0\" class=\"row_heading level0 row0\" >17</th>\n",
              "      <td id=\"T_a77b3_row0_col0\" class=\"data row0 col0\" >-0.391927</td>\n",
              "      <td id=\"T_a77b3_row0_col1\" class=\"data row0 col1\" >-0.139539</td>\n",
              "      <td id=\"T_a77b3_row0_col2\" class=\"data row0 col2\" >-0.220841</td>\n",
              "      <td id=\"T_a77b3_row0_col3\" class=\"data row0 col3\" >-0.241557</td>\n",
              "      <td id=\"T_a77b3_row0_col4\" class=\"data row0 col4\" >-0.267864</td>\n",
              "      <td id=\"T_a77b3_row0_col5\" class=\"data row0 col5\" >-0.227556</td>\n",
              "      <td id=\"T_a77b3_row0_col6\" class=\"data row0 col6\" >-0.214928</td>\n",
              "      <td id=\"T_a77b3_row0_col7\" class=\"data row0 col7\" >-0.261741</td>\n",
              "      <td id=\"T_a77b3_row0_col8\" class=\"data row0 col8\" >-0.247050</td>\n",
              "      <td id=\"T_a77b3_row0_col9\" class=\"data row0 col9\" >-0.187549</td>\n",
              "      <td id=\"T_a77b3_row0_col10\" class=\"data row0 col10\" >-0.256819</td>\n",
              "      <td id=\"T_a77b3_row0_col11\" class=\"data row0 col11\" >-0.237743</td>\n",
              "      <td id=\"T_a77b3_row0_col12\" class=\"data row0 col12\" >-0.218364</td>\n",
              "      <td id=\"T_a77b3_row0_col13\" class=\"data row0 col13\" >-0.174136</td>\n",
              "      <td id=\"T_a77b3_row0_col14\" class=\"data row0 col14\" >-0.222055</td>\n",
              "      <td id=\"T_a77b3_row0_col15\" class=\"data row0 col15\" >-0.184465</td>\n",
              "      <td id=\"T_a77b3_row0_col16\" class=\"data row0 col16\" >-0.210030</td>\n",
              "      <td id=\"T_a77b3_row0_col17\" class=\"data row0 col17\" >-0.376704</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row1\" class=\"row_heading level0 row1\" >16</th>\n",
              "      <td id=\"T_a77b3_row1_col0\" class=\"data row1 col0\" >-0.181526</td>\n",
              "      <td id=\"T_a77b3_row1_col1\" class=\"data row1 col1\" >0.091511</td>\n",
              "      <td id=\"T_a77b3_row1_col2\" class=\"data row1 col2\" >0.049025</td>\n",
              "      <td id=\"T_a77b3_row1_col3\" class=\"data row1 col3\" >0.075621</td>\n",
              "      <td id=\"T_a77b3_row1_col4\" class=\"data row1 col4\" >0.084072</td>\n",
              "      <td id=\"T_a77b3_row1_col5\" class=\"data row1 col5\" >0.126894</td>\n",
              "      <td id=\"T_a77b3_row1_col6\" class=\"data row1 col6\" >0.025037</td>\n",
              "      <td id=\"T_a77b3_row1_col7\" class=\"data row1 col7\" >0.089799</td>\n",
              "      <td id=\"T_a77b3_row1_col8\" class=\"data row1 col8\" >0.119387</td>\n",
              "      <td id=\"T_a77b3_row1_col9\" class=\"data row1 col9\" >0.031799</td>\n",
              "      <td id=\"T_a77b3_row1_col10\" class=\"data row1 col10\" >0.029457</td>\n",
              "      <td id=\"T_a77b3_row1_col11\" class=\"data row1 col11\" >0.056401</td>\n",
              "      <td id=\"T_a77b3_row1_col12\" class=\"data row1 col12\" >0.070771</td>\n",
              "      <td id=\"T_a77b3_row1_col13\" class=\"data row1 col13\" >0.127979</td>\n",
              "      <td id=\"T_a77b3_row1_col14\" class=\"data row1 col14\" >0.631040</td>\n",
              "      <td id=\"T_a77b3_row1_col15\" class=\"data row1 col15\" >0.092900</td>\n",
              "      <td id=\"T_a77b3_row1_col16\" class=\"data row1 col16\" >0.070347</td>\n",
              "      <td id=\"T_a77b3_row1_col17\" class=\"data row1 col17\" >-0.217973</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row2\" class=\"row_heading level0 row2\" >15</th>\n",
              "      <td id=\"T_a77b3_row2_col0\" class=\"data row2 col0\" >-0.232618</td>\n",
              "      <td id=\"T_a77b3_row2_col1\" class=\"data row2 col1\" >0.045900</td>\n",
              "      <td id=\"T_a77b3_row2_col2\" class=\"data row2 col2\" >0.052020</td>\n",
              "      <td id=\"T_a77b3_row2_col3\" class=\"data row2 col3\" >-0.005197</td>\n",
              "      <td id=\"T_a77b3_row2_col4\" class=\"data row2 col4\" >0.000395</td>\n",
              "      <td id=\"T_a77b3_row2_col5\" class=\"data row2 col5\" >0.034379</td>\n",
              "      <td id=\"T_a77b3_row2_col6\" class=\"data row2 col6\" >-0.009619</td>\n",
              "      <td id=\"T_a77b3_row2_col7\" class=\"data row2 col7\" >-0.065826</td>\n",
              "      <td id=\"T_a77b3_row2_col8\" class=\"data row2 col8\" >0.019727</td>\n",
              "      <td id=\"T_a77b3_row2_col9\" class=\"data row2 col9\" >0.028401</td>\n",
              "      <td id=\"T_a77b3_row2_col10\" class=\"data row2 col10\" >-0.006816</td>\n",
              "      <td id=\"T_a77b3_row2_col11\" class=\"data row2 col11\" >-0.000174</td>\n",
              "      <td id=\"T_a77b3_row2_col12\" class=\"data row2 col12\" >-0.096192</td>\n",
              "      <td id=\"T_a77b3_row2_col13\" class=\"data row2 col13\" >0.104321</td>\n",
              "      <td id=\"T_a77b3_row2_col14\" class=\"data row2 col14\" >-0.019476</td>\n",
              "      <td id=\"T_a77b3_row2_col15\" class=\"data row2 col15\" >-0.543809</td>\n",
              "      <td id=\"T_a77b3_row2_col16\" class=\"data row2 col16\" >-0.034718</td>\n",
              "      <td id=\"T_a77b3_row2_col17\" class=\"data row2 col17\" >-0.259969</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row3\" class=\"row_heading level0 row3\" >14</th>\n",
              "      <td id=\"T_a77b3_row3_col0\" class=\"data row3 col0\" >-0.282713</td>\n",
              "      <td id=\"T_a77b3_row3_col1\" class=\"data row3 col1\" >0.054374</td>\n",
              "      <td id=\"T_a77b3_row3_col2\" class=\"data row3 col2\" >0.038606</td>\n",
              "      <td id=\"T_a77b3_row3_col3\" class=\"data row3 col3\" >0.007267</td>\n",
              "      <td id=\"T_a77b3_row3_col4\" class=\"data row3 col4\" >0.041968</td>\n",
              "      <td id=\"T_a77b3_row3_col5\" class=\"data row3 col5\" >0.059770</td>\n",
              "      <td id=\"T_a77b3_row3_col6\" class=\"data row3 col6\" >0.071165</td>\n",
              "      <td id=\"T_a77b3_row3_col7\" class=\"data row3 col7\" >0.043081</td>\n",
              "      <td id=\"T_a77b3_row3_col8\" class=\"data row3 col8\" >-0.025688</td>\n",
              "      <td id=\"T_a77b3_row3_col9\" class=\"data row3 col9\" >0.098168</td>\n",
              "      <td id=\"T_a77b3_row3_col10\" class=\"data row3 col10\" >0.604060</td>\n",
              "      <td id=\"T_a77b3_row3_col11\" class=\"data row3 col11\" >0.137944</td>\n",
              "      <td id=\"T_a77b3_row3_col12\" class=\"data row3 col12\" >0.025857</td>\n",
              "      <td id=\"T_a77b3_row3_col13\" class=\"data row3 col13\" >0.031061</td>\n",
              "      <td id=\"T_a77b3_row3_col14\" class=\"data row3 col14\" >-0.105312</td>\n",
              "      <td id=\"T_a77b3_row3_col15\" class=\"data row3 col15\" >0.010122</td>\n",
              "      <td id=\"T_a77b3_row3_col16\" class=\"data row3 col16\" >-0.030717</td>\n",
              "      <td id=\"T_a77b3_row3_col17\" class=\"data row3 col17\" >-0.217375</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row4\" class=\"row_heading level0 row4\" >13</th>\n",
              "      <td id=\"T_a77b3_row4_col0\" class=\"data row4 col0\" >-0.158076</td>\n",
              "      <td id=\"T_a77b3_row4_col1\" class=\"data row4 col1\" >0.036785</td>\n",
              "      <td id=\"T_a77b3_row4_col2\" class=\"data row4 col2\" >0.018971</td>\n",
              "      <td id=\"T_a77b3_row4_col3\" class=\"data row4 col3\" >-0.027330</td>\n",
              "      <td id=\"T_a77b3_row4_col4\" class=\"data row4 col4\" >-0.019688</td>\n",
              "      <td id=\"T_a77b3_row4_col5\" class=\"data row4 col5\" >0.593380</td>\n",
              "      <td id=\"T_a77b3_row4_col6\" class=\"data row4 col6\" >-0.024313</td>\n",
              "      <td id=\"T_a77b3_row4_col7\" class=\"data row4 col7\" >0.017723</td>\n",
              "      <td id=\"T_a77b3_row4_col8\" class=\"data row4 col8\" >-0.008807</td>\n",
              "      <td id=\"T_a77b3_row4_col9\" class=\"data row4 col9\" >-0.004167</td>\n",
              "      <td id=\"T_a77b3_row4_col10\" class=\"data row4 col10\" >0.008142</td>\n",
              "      <td id=\"T_a77b3_row4_col11\" class=\"data row4 col11\" >0.013268</td>\n",
              "      <td id=\"T_a77b3_row4_col12\" class=\"data row4 col12\" >0.016607</td>\n",
              "      <td id=\"T_a77b3_row4_col13\" class=\"data row4 col13\" >0.120214</td>\n",
              "      <td id=\"T_a77b3_row4_col14\" class=\"data row4 col14\" >0.020721</td>\n",
              "      <td id=\"T_a77b3_row4_col15\" class=\"data row4 col15\" >-0.724890</td>\n",
              "      <td id=\"T_a77b3_row4_col16\" class=\"data row4 col16\" >0.017972</td>\n",
              "      <td id=\"T_a77b3_row4_col17\" class=\"data row4 col17\" >-0.183656</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row5\" class=\"row_heading level0 row5\" >12</th>\n",
              "      <td id=\"T_a77b3_row5_col0\" class=\"data row5 col0\" >-0.246124</td>\n",
              "      <td id=\"T_a77b3_row5_col1\" class=\"data row5 col1\" >-0.012146</td>\n",
              "      <td id=\"T_a77b3_row5_col2\" class=\"data row5 col2\" >0.005344</td>\n",
              "      <td id=\"T_a77b3_row5_col3\" class=\"data row5 col3\" >0.000279</td>\n",
              "      <td id=\"T_a77b3_row5_col4\" class=\"data row5 col4\" >0.018169</td>\n",
              "      <td id=\"T_a77b3_row5_col5\" class=\"data row5 col5\" >-0.561057</td>\n",
              "      <td id=\"T_a77b3_row5_col6\" class=\"data row5 col6\" >0.054172</td>\n",
              "      <td id=\"T_a77b3_row5_col7\" class=\"data row5 col7\" >-0.038071</td>\n",
              "      <td id=\"T_a77b3_row5_col8\" class=\"data row5 col8\" >0.032036</td>\n",
              "      <td id=\"T_a77b3_row5_col9\" class=\"data row5 col9\" >-0.020324</td>\n",
              "      <td id=\"T_a77b3_row5_col10\" class=\"data row5 col10\" >0.034318</td>\n",
              "      <td id=\"T_a77b3_row5_col11\" class=\"data row5 col11\" >-0.049289</td>\n",
              "      <td id=\"T_a77b3_row5_col12\" class=\"data row5 col12\" >0.073412</td>\n",
              "      <td id=\"T_a77b3_row5_col13\" class=\"data row5 col13\" >0.606309</td>\n",
              "      <td id=\"T_a77b3_row5_col14\" class=\"data row5 col14\" >-0.022850</td>\n",
              "      <td id=\"T_a77b3_row5_col15\" class=\"data row5 col15\" >-0.032247</td>\n",
              "      <td id=\"T_a77b3_row5_col16\" class=\"data row5 col16\" >0.064113</td>\n",
              "      <td id=\"T_a77b3_row5_col17\" class=\"data row5 col17\" >-0.089909</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row6\" class=\"row_heading level0 row6\" >11</th>\n",
              "      <td id=\"T_a77b3_row6_col0\" class=\"data row6 col0\" >-0.185192</td>\n",
              "      <td id=\"T_a77b3_row6_col1\" class=\"data row6 col1\" >0.069353</td>\n",
              "      <td id=\"T_a77b3_row6_col2\" class=\"data row6 col2\" >0.097561</td>\n",
              "      <td id=\"T_a77b3_row6_col3\" class=\"data row6 col3\" >0.032864</td>\n",
              "      <td id=\"T_a77b3_row6_col4\" class=\"data row6 col4\" >-0.014972</td>\n",
              "      <td id=\"T_a77b3_row6_col5\" class=\"data row6 col5\" >-0.027109</td>\n",
              "      <td id=\"T_a77b3_row6_col6\" class=\"data row6 col6\" >-0.036939</td>\n",
              "      <td id=\"T_a77b3_row6_col7\" class=\"data row6 col7\" >-0.002524</td>\n",
              "      <td id=\"T_a77b3_row6_col8\" class=\"data row6 col8\" >0.103943</td>\n",
              "      <td id=\"T_a77b3_row6_col9\" class=\"data row6 col9\" >0.028907</td>\n",
              "      <td id=\"T_a77b3_row6_col10\" class=\"data row6 col10\" >0.074374</td>\n",
              "      <td id=\"T_a77b3_row6_col11\" class=\"data row6 col11\" >0.617428</td>\n",
              "      <td id=\"T_a77b3_row6_col12\" class=\"data row6 col12\" >0.114530</td>\n",
              "      <td id=\"T_a77b3_row6_col13\" class=\"data row6 col13\" >-0.046659</td>\n",
              "      <td id=\"T_a77b3_row6_col14\" class=\"data row6 col14\" >-0.555414</td>\n",
              "      <td id=\"T_a77b3_row6_col15\" class=\"data row6 col15\" >0.052198</td>\n",
              "      <td id=\"T_a77b3_row6_col16\" class=\"data row6 col16\" >0.010841</td>\n",
              "      <td id=\"T_a77b3_row6_col17\" class=\"data row6 col17\" >-0.275293</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row7\" class=\"row_heading level0 row7\" >10</th>\n",
              "      <td id=\"T_a77b3_row7_col0\" class=\"data row7 col0\" >-0.225088</td>\n",
              "      <td id=\"T_a77b3_row7_col1\" class=\"data row7 col1\" >0.031650</td>\n",
              "      <td id=\"T_a77b3_row7_col2\" class=\"data row7 col2\" >0.017540</td>\n",
              "      <td id=\"T_a77b3_row7_col3\" class=\"data row7 col3\" >0.028642</td>\n",
              "      <td id=\"T_a77b3_row7_col4\" class=\"data row7 col4\" >-0.081492</td>\n",
              "      <td id=\"T_a77b3_row7_col5\" class=\"data row7 col5\" >0.080106</td>\n",
              "      <td id=\"T_a77b3_row7_col6\" class=\"data row7 col6\" >-0.005046</td>\n",
              "      <td id=\"T_a77b3_row7_col7\" class=\"data row7 col7\" >0.033473</td>\n",
              "      <td id=\"T_a77b3_row7_col8\" class=\"data row7 col8\" >-0.017546</td>\n",
              "      <td id=\"T_a77b3_row7_col9\" class=\"data row7 col9\" >0.682550</td>\n",
              "      <td id=\"T_a77b3_row7_col10\" class=\"data row7 col10\" >0.016555</td>\n",
              "      <td id=\"T_a77b3_row7_col11\" class=\"data row7 col11\" >-0.002671</td>\n",
              "      <td id=\"T_a77b3_row7_col12\" class=\"data row7 col12\" >0.094250</td>\n",
              "      <td id=\"T_a77b3_row7_col13\" class=\"data row7 col13\" >-0.100588</td>\n",
              "      <td id=\"T_a77b3_row7_col14\" class=\"data row7 col14\" >0.003173</td>\n",
              "      <td id=\"T_a77b3_row7_col15\" class=\"data row7 col15\" >0.655949</td>\n",
              "      <td id=\"T_a77b3_row7_col16\" class=\"data row7 col16\" >0.108708</td>\n",
              "      <td id=\"T_a77b3_row7_col17\" class=\"data row7 col17\" >-0.182045</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row8\" class=\"row_heading level0 row8\" >9</th>\n",
              "      <td id=\"T_a77b3_row8_col0\" class=\"data row8 col0\" >-0.206491</td>\n",
              "      <td id=\"T_a77b3_row8_col1\" class=\"data row8 col1\" >0.019541</td>\n",
              "      <td id=\"T_a77b3_row8_col2\" class=\"data row8 col2\" >-0.050962</td>\n",
              "      <td id=\"T_a77b3_row8_col3\" class=\"data row8 col3\" >0.016401</td>\n",
              "      <td id=\"T_a77b3_row8_col4\" class=\"data row8 col4\" >0.077562</td>\n",
              "      <td id=\"T_a77b3_row8_col5\" class=\"data row8 col5\" >0.058712</td>\n",
              "      <td id=\"T_a77b3_row8_col6\" class=\"data row8 col6\" >-0.012032</td>\n",
              "      <td id=\"T_a77b3_row8_col7\" class=\"data row8 col7\" >0.105647</td>\n",
              "      <td id=\"T_a77b3_row8_col8\" class=\"data row8 col8\" >-0.033697</td>\n",
              "      <td id=\"T_a77b3_row8_col9\" class=\"data row8 col9\" >0.074167</td>\n",
              "      <td id=\"T_a77b3_row8_col10\" class=\"data row8 col10\" >-0.039611</td>\n",
              "      <td id=\"T_a77b3_row8_col11\" class=\"data row8 col11\" >0.070101</td>\n",
              "      <td id=\"T_a77b3_row8_col12\" class=\"data row8 col12\" >-0.033076</td>\n",
              "      <td id=\"T_a77b3_row8_col13\" class=\"data row8 col13\" >0.027844</td>\n",
              "      <td id=\"T_a77b3_row8_col14\" class=\"data row8 col14\" >0.054793</td>\n",
              "      <td id=\"T_a77b3_row8_col15\" class=\"data row8 col15\" >-0.012668</td>\n",
              "      <td id=\"T_a77b3_row8_col16\" class=\"data row8 col16\" >0.126000</td>\n",
              "      <td id=\"T_a77b3_row8_col17\" class=\"data row8 col17\" >-0.344227</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row9\" class=\"row_heading level0 row9\" >8</th>\n",
              "      <td id=\"T_a77b3_row9_col0\" class=\"data row9 col0\" >-0.163820</td>\n",
              "      <td id=\"T_a77b3_row9_col1\" class=\"data row9 col1\" >0.106201</td>\n",
              "      <td id=\"T_a77b3_row9_col2\" class=\"data row9 col2\" >0.015337</td>\n",
              "      <td id=\"T_a77b3_row9_col3\" class=\"data row9 col3\" >0.052586</td>\n",
              "      <td id=\"T_a77b3_row9_col4\" class=\"data row9 col4\" >-0.084571</td>\n",
              "      <td id=\"T_a77b3_row9_col5\" class=\"data row9 col5\" >-0.015096</td>\n",
              "      <td id=\"T_a77b3_row9_col6\" class=\"data row9 col6\" >-0.002875</td>\n",
              "      <td id=\"T_a77b3_row9_col7\" class=\"data row9 col7\" >0.009687</td>\n",
              "      <td id=\"T_a77b3_row9_col8\" class=\"data row9 col8\" >-0.028688</td>\n",
              "      <td id=\"T_a77b3_row9_col9\" class=\"data row9 col9\" >0.069280</td>\n",
              "      <td id=\"T_a77b3_row9_col10\" class=\"data row9 col10\" >-0.009954</td>\n",
              "      <td id=\"T_a77b3_row9_col11\" class=\"data row9 col11\" >0.024730</td>\n",
              "      <td id=\"T_a77b3_row9_col12\" class=\"data row9 col12\" >0.056021</td>\n",
              "      <td id=\"T_a77b3_row9_col13\" class=\"data row9 col13\" >0.014051</td>\n",
              "      <td id=\"T_a77b3_row9_col14\" class=\"data row9 col14\" >0.066418</td>\n",
              "      <td id=\"T_a77b3_row9_col15\" class=\"data row9 col15\" >-0.000710</td>\n",
              "      <td id=\"T_a77b3_row9_col16\" class=\"data row9 col16\" >0.099735</td>\n",
              "      <td id=\"T_a77b3_row9_col17\" class=\"data row9 col17\" >-0.191588</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row10\" class=\"row_heading level0 row10\" >7</th>\n",
              "      <td id=\"T_a77b3_row10_col0\" class=\"data row10 col0\" >-0.224483</td>\n",
              "      <td id=\"T_a77b3_row10_col1\" class=\"data row10 col1\" >-0.016982</td>\n",
              "      <td id=\"T_a77b3_row10_col2\" class=\"data row10 col2\" >-0.021625</td>\n",
              "      <td id=\"T_a77b3_row10_col3\" class=\"data row10 col3\" >-0.078328</td>\n",
              "      <td id=\"T_a77b3_row10_col4\" class=\"data row10 col4\" >0.084731</td>\n",
              "      <td id=\"T_a77b3_row10_col5\" class=\"data row10 col5\" >0.038365</td>\n",
              "      <td id=\"T_a77b3_row10_col6\" class=\"data row10 col6\" >-0.003889</td>\n",
              "      <td id=\"T_a77b3_row10_col7\" class=\"data row10 col7\" >0.038092</td>\n",
              "      <td id=\"T_a77b3_row10_col8\" class=\"data row10 col8\" >0.014422</td>\n",
              "      <td id=\"T_a77b3_row10_col9\" class=\"data row10 col9\" >-0.040595</td>\n",
              "      <td id=\"T_a77b3_row10_col10\" class=\"data row10 col10\" >0.080816</td>\n",
              "      <td id=\"T_a77b3_row10_col11\" class=\"data row10 col11\" >-0.023443</td>\n",
              "      <td id=\"T_a77b3_row10_col12\" class=\"data row10 col12\" >-0.018065</td>\n",
              "      <td id=\"T_a77b3_row10_col13\" class=\"data row10 col13\" >-0.063860</td>\n",
              "      <td id=\"T_a77b3_row10_col14\" class=\"data row10 col14\" >-0.046342</td>\n",
              "      <td id=\"T_a77b3_row10_col15\" class=\"data row10 col15\" >0.029629</td>\n",
              "      <td id=\"T_a77b3_row10_col16\" class=\"data row10 col16\" >0.011449</td>\n",
              "      <td id=\"T_a77b3_row10_col17\" class=\"data row10 col17\" >-0.164302</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row11\" class=\"row_heading level0 row11\" >6</th>\n",
              "      <td id=\"T_a77b3_row11_col0\" class=\"data row11 col0\" >-0.120235</td>\n",
              "      <td id=\"T_a77b3_row11_col1\" class=\"data row11 col1\" >0.000389</td>\n",
              "      <td id=\"T_a77b3_row11_col2\" class=\"data row11 col2\" >-0.097354</td>\n",
              "      <td id=\"T_a77b3_row11_col3\" class=\"data row11 col3\" >-0.572524</td>\n",
              "      <td id=\"T_a77b3_row11_col4\" class=\"data row11 col4\" >0.018257</td>\n",
              "      <td id=\"T_a77b3_row11_col5\" class=\"data row11 col5\" >-0.052131</td>\n",
              "      <td id=\"T_a77b3_row11_col6\" class=\"data row11 col6\" >-0.015100</td>\n",
              "      <td id=\"T_a77b3_row11_col7\" class=\"data row11 col7\" >0.012660</td>\n",
              "      <td id=\"T_a77b3_row11_col8\" class=\"data row11 col8\" >0.030188</td>\n",
              "      <td id=\"T_a77b3_row11_col9\" class=\"data row11 col9\" >0.017771</td>\n",
              "      <td id=\"T_a77b3_row11_col10\" class=\"data row11 col10\" >0.007746</td>\n",
              "      <td id=\"T_a77b3_row11_col11\" class=\"data row11 col11\" >-0.019192</td>\n",
              "      <td id=\"T_a77b3_row11_col12\" class=\"data row11 col12\" >-0.078896</td>\n",
              "      <td id=\"T_a77b3_row11_col13\" class=\"data row11 col13\" >-0.672908</td>\n",
              "      <td id=\"T_a77b3_row11_col14\" class=\"data row11 col14\" >-0.671066</td>\n",
              "      <td id=\"T_a77b3_row11_col15\" class=\"data row11 col15\" >-0.010713</td>\n",
              "      <td id=\"T_a77b3_row11_col16\" class=\"data row11 col16\" >-0.038660</td>\n",
              "      <td id=\"T_a77b3_row11_col17\" class=\"data row11 col17\" >-0.231980</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row12\" class=\"row_heading level0 row12\" >5</th>\n",
              "      <td id=\"T_a77b3_row12_col0\" class=\"data row12 col0\" >-0.314515</td>\n",
              "      <td id=\"T_a77b3_row12_col1\" class=\"data row12 col1\" >-0.546959</td>\n",
              "      <td id=\"T_a77b3_row12_col2\" class=\"data row12 col2\" >-0.072256</td>\n",
              "      <td id=\"T_a77b3_row12_col3\" class=\"data row12 col3\" >-0.039974</td>\n",
              "      <td id=\"T_a77b3_row12_col4\" class=\"data row12 col4\" >-0.070928</td>\n",
              "      <td id=\"T_a77b3_row12_col5\" class=\"data row12 col5\" >0.027642</td>\n",
              "      <td id=\"T_a77b3_row12_col6\" class=\"data row12 col6\" >-0.054822</td>\n",
              "      <td id=\"T_a77b3_row12_col7\" class=\"data row12 col7\" >0.065270</td>\n",
              "      <td id=\"T_a77b3_row12_col8\" class=\"data row12 col8\" >0.000164</td>\n",
              "      <td id=\"T_a77b3_row12_col9\" class=\"data row12 col9\" >0.051575</td>\n",
              "      <td id=\"T_a77b3_row12_col10\" class=\"data row12 col10\" >0.656660</td>\n",
              "      <td id=\"T_a77b3_row12_col11\" class=\"data row12 col11\" >-0.579394</td>\n",
              "      <td id=\"T_a77b3_row12_col12\" class=\"data row12 col12\" >0.008260</td>\n",
              "      <td id=\"T_a77b3_row12_col13\" class=\"data row12 col13\" >-0.073150</td>\n",
              "      <td id=\"T_a77b3_row12_col14\" class=\"data row12 col14\" >-0.024827</td>\n",
              "      <td id=\"T_a77b3_row12_col15\" class=\"data row12 col15\" >-0.636496</td>\n",
              "      <td id=\"T_a77b3_row12_col16\" class=\"data row12 col16\" >0.013832</td>\n",
              "      <td id=\"T_a77b3_row12_col17\" class=\"data row12 col17\" >-0.226781</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row13\" class=\"row_heading level0 row13\" >4</th>\n",
              "      <td id=\"T_a77b3_row13_col0\" class=\"data row13 col0\" >-0.250362</td>\n",
              "      <td id=\"T_a77b3_row13_col1\" class=\"data row13 col1\" >0.030672</td>\n",
              "      <td id=\"T_a77b3_row13_col2\" class=\"data row13 col2\" >-0.000859</td>\n",
              "      <td id=\"T_a77b3_row13_col3\" class=\"data row13 col3\" >0.018737</td>\n",
              "      <td id=\"T_a77b3_row13_col4\" class=\"data row13 col4\" >0.031588</td>\n",
              "      <td id=\"T_a77b3_row13_col5\" class=\"data row13 col5\" >0.022293</td>\n",
              "      <td id=\"T_a77b3_row13_col6\" class=\"data row13 col6\" >0.064315</td>\n",
              "      <td id=\"T_a77b3_row13_col7\" class=\"data row13 col7\" >0.052448</td>\n",
              "      <td id=\"T_a77b3_row13_col8\" class=\"data row13 col8\" >-0.010397</td>\n",
              "      <td id=\"T_a77b3_row13_col9\" class=\"data row13 col9\" >0.045333</td>\n",
              "      <td id=\"T_a77b3_row13_col10\" class=\"data row13 col10\" >-0.025479</td>\n",
              "      <td id=\"T_a77b3_row13_col11\" class=\"data row13 col11\" >-0.011201</td>\n",
              "      <td id=\"T_a77b3_row13_col12\" class=\"data row13 col12\" >-0.082121</td>\n",
              "      <td id=\"T_a77b3_row13_col13\" class=\"data row13 col13\" >0.014877</td>\n",
              "      <td id=\"T_a77b3_row13_col14\" class=\"data row13 col14\" >0.010056</td>\n",
              "      <td id=\"T_a77b3_row13_col15\" class=\"data row13 col15\" >0.034767</td>\n",
              "      <td id=\"T_a77b3_row13_col16\" class=\"data row13 col16\" >-0.030732</td>\n",
              "      <td id=\"T_a77b3_row13_col17\" class=\"data row13 col17\" >-0.246050</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row14\" class=\"row_heading level0 row14\" >3</th>\n",
              "      <td id=\"T_a77b3_row14_col0\" class=\"data row14 col0\" >-0.254964</td>\n",
              "      <td id=\"T_a77b3_row14_col1\" class=\"data row14 col1\" >-0.012599</td>\n",
              "      <td id=\"T_a77b3_row14_col2\" class=\"data row14 col2\" >-0.056346</td>\n",
              "      <td id=\"T_a77b3_row14_col3\" class=\"data row14 col3\" >0.010130</td>\n",
              "      <td id=\"T_a77b3_row14_col4\" class=\"data row14 col4\" >0.094600</td>\n",
              "      <td id=\"T_a77b3_row14_col5\" class=\"data row14 col5\" >0.617470</td>\n",
              "      <td id=\"T_a77b3_row14_col6\" class=\"data row14 col6\" >0.031610</td>\n",
              "      <td id=\"T_a77b3_row14_col7\" class=\"data row14 col7\" >-0.008772</td>\n",
              "      <td id=\"T_a77b3_row14_col8\" class=\"data row14 col8\" >-0.079897</td>\n",
              "      <td id=\"T_a77b3_row14_col9\" class=\"data row14 col9\" >0.643965</td>\n",
              "      <td id=\"T_a77b3_row14_col10\" class=\"data row14 col10\" >0.052359</td>\n",
              "      <td id=\"T_a77b3_row14_col11\" class=\"data row14 col11\" >-0.023289</td>\n",
              "      <td id=\"T_a77b3_row14_col12\" class=\"data row14 col12\" >0.083812</td>\n",
              "      <td id=\"T_a77b3_row14_col13\" class=\"data row14 col13\" >0.033408</td>\n",
              "      <td id=\"T_a77b3_row14_col14\" class=\"data row14 col14\" >-0.034813</td>\n",
              "      <td id=\"T_a77b3_row14_col15\" class=\"data row14 col15\" >-0.001923</td>\n",
              "      <td id=\"T_a77b3_row14_col16\" class=\"data row14 col16\" >0.081275</td>\n",
              "      <td id=\"T_a77b3_row14_col17\" class=\"data row14 col17\" >-0.278546</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row15\" class=\"row_heading level0 row15\" >2</th>\n",
              "      <td id=\"T_a77b3_row15_col0\" class=\"data row15 col0\" >-0.196345</td>\n",
              "      <td id=\"T_a77b3_row15_col1\" class=\"data row15 col1\" >0.163565</td>\n",
              "      <td id=\"T_a77b3_row15_col2\" class=\"data row15 col2\" >0.072376</td>\n",
              "      <td id=\"T_a77b3_row15_col3\" class=\"data row15 col3\" >-0.027496</td>\n",
              "      <td id=\"T_a77b3_row15_col4\" class=\"data row15 col4\" >0.038418</td>\n",
              "      <td id=\"T_a77b3_row15_col5\" class=\"data row15 col5\" >-0.025729</td>\n",
              "      <td id=\"T_a77b3_row15_col6\" class=\"data row15 col6\" >0.151023</td>\n",
              "      <td id=\"T_a77b3_row15_col7\" class=\"data row15 col7\" >0.344711</td>\n",
              "      <td id=\"T_a77b3_row15_col8\" class=\"data row15 col8\" >0.050308</td>\n",
              "      <td id=\"T_a77b3_row15_col9\" class=\"data row15 col9\" >0.032914</td>\n",
              "      <td id=\"T_a77b3_row15_col10\" class=\"data row15 col10\" >0.111927</td>\n",
              "      <td id=\"T_a77b3_row15_col11\" class=\"data row15 col11\" >0.012585</td>\n",
              "      <td id=\"T_a77b3_row15_col12\" class=\"data row15 col12\" >0.100616</td>\n",
              "      <td id=\"T_a77b3_row15_col13\" class=\"data row15 col13\" >0.046376</td>\n",
              "      <td id=\"T_a77b3_row15_col14\" class=\"data row15 col14\" >0.033953</td>\n",
              "      <td id=\"T_a77b3_row15_col15\" class=\"data row15 col15\" >-0.031732</td>\n",
              "      <td id=\"T_a77b3_row15_col16\" class=\"data row15 col16\" >0.227661</td>\n",
              "      <td id=\"T_a77b3_row15_col17\" class=\"data row15 col17\" >-0.309555</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row16\" class=\"row_heading level0 row16\" >1</th>\n",
              "      <td id=\"T_a77b3_row16_col0\" class=\"data row16 col0\" >-0.270848</td>\n",
              "      <td id=\"T_a77b3_row16_col1\" class=\"data row16 col1\" >0.066843</td>\n",
              "      <td id=\"T_a77b3_row16_col2\" class=\"data row16 col2\" >0.000477</td>\n",
              "      <td id=\"T_a77b3_row16_col3\" class=\"data row16 col3\" >0.091013</td>\n",
              "      <td id=\"T_a77b3_row16_col4\" class=\"data row16 col4\" >0.038092</td>\n",
              "      <td id=\"T_a77b3_row16_col5\" class=\"data row16 col5\" >0.027875</td>\n",
              "      <td id=\"T_a77b3_row16_col6\" class=\"data row16 col6\" >0.109410</td>\n",
              "      <td id=\"T_a77b3_row16_col7\" class=\"data row16 col7\" >0.022072</td>\n",
              "      <td id=\"T_a77b3_row16_col8\" class=\"data row16 col8\" >0.206411</td>\n",
              "      <td id=\"T_a77b3_row16_col9\" class=\"data row16 col9\" >-0.050542</td>\n",
              "      <td id=\"T_a77b3_row16_col10\" class=\"data row16 col10\" >0.079064</td>\n",
              "      <td id=\"T_a77b3_row16_col11\" class=\"data row16 col11\" >-0.053206</td>\n",
              "      <td id=\"T_a77b3_row16_col12\" class=\"data row16 col12\" >0.018045</td>\n",
              "      <td id=\"T_a77b3_row16_col13\" class=\"data row16 col13\" >-0.022353</td>\n",
              "      <td id=\"T_a77b3_row16_col14\" class=\"data row16 col14\" >0.059998</td>\n",
              "      <td id=\"T_a77b3_row16_col15\" class=\"data row16 col15\" >0.095573</td>\n",
              "      <td id=\"T_a77b3_row16_col16\" class=\"data row16 col16\" >0.182018</td>\n",
              "      <td id=\"T_a77b3_row16_col17\" class=\"data row16 col17\" >0.211084</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_a77b3_level0_row17\" class=\"row_heading level0 row17\" >0</th>\n",
              "      <td id=\"T_a77b3_row17_col0\" class=\"data row17 col0\" >-0.382634</td>\n",
              "      <td id=\"T_a77b3_row17_col1\" class=\"data row17 col1\" >-0.110350</td>\n",
              "      <td id=\"T_a77b3_row17_col2\" class=\"data row17 col2\" >-0.243671</td>\n",
              "      <td id=\"T_a77b3_row17_col3\" class=\"data row17 col3\" >-0.252601</td>\n",
              "      <td id=\"T_a77b3_row17_col4\" class=\"data row17 col4\" >-0.232048</td>\n",
              "      <td id=\"T_a77b3_row17_col5\" class=\"data row17 col5\" >-0.238052</td>\n",
              "      <td id=\"T_a77b3_row17_col6\" class=\"data row17 col6\" >-0.225332</td>\n",
              "      <td id=\"T_a77b3_row17_col7\" class=\"data row17 col7\" >-0.109110</td>\n",
              "      <td id=\"T_a77b3_row17_col8\" class=\"data row17 col8\" >-0.259814</td>\n",
              "      <td id=\"T_a77b3_row17_col9\" class=\"data row17 col9\" >-0.237043</td>\n",
              "      <td id=\"T_a77b3_row17_col10\" class=\"data row17 col10\" >-0.180806</td>\n",
              "      <td id=\"T_a77b3_row17_col11\" class=\"data row17 col11\" >-0.215114</td>\n",
              "      <td id=\"T_a77b3_row17_col12\" class=\"data row17 col12\" >-0.215547</td>\n",
              "      <td id=\"T_a77b3_row17_col13\" class=\"data row17 col13\" >-0.241066</td>\n",
              "      <td id=\"T_a77b3_row17_col14\" class=\"data row17 col14\" >-0.353182</td>\n",
              "      <td id=\"T_a77b3_row17_col15\" class=\"data row17 col15\" >-0.210757</td>\n",
              "      <td id=\"T_a77b3_row17_col16\" class=\"data row17 col16\" >-0.262280</td>\n",
              "      <td id=\"T_a77b3_row17_col17\" class=\"data row17 col17\" >-0.332749</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "R = getAllRewards()\n",
        "# print(\"r.size =\", r.size())\n",
        "R = R.resize((R.size(1)))\n",
        "c = plotStates(env.getGrid(), R, True)\n",
        "plotStatesSmall(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JmKU2uoc-6Du",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 578
        },
        "outputId": "820a5b0d-7b71-4ab3-92e3-8c6444274e76"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "env.plotGrid(env.getGrid())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QcmJyQ3cPsQa"
      },
      "source": [
        "## Policy Evaluation & Improvement "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_2Vi-yC8Ppz9"
      },
      "outputs": [],
      "source": [
        "def improvePolicy(policy, Q, state, eps=0.1):\n",
        "    q = torch.tensor([Q[state][0], Q[state][1], Q[state][2], Q[state][3], Q[state][4], Q[state][5], Q[state][6], Q[state][7]])\n",
        "\n",
        "    policy[state] = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])\n",
        "    idx = 0\n",
        "    _, indices = torch.sort(q, descending=True)\n",
        "    policy[state][indices[idx]] = (1.0-eps)\n",
        "\n",
        "    num_actions = 8.0\n",
        "    policy[state][0] += (eps/num_actions)\n",
        "    policy[state][1] += (eps/num_actions)\n",
        "    policy[state][2] += (eps/num_actions)\n",
        "    policy[state][3] += (eps/num_actions)\n",
        "    policy[state][4] += (eps/num_actions)\n",
        "    policy[state][5] += (eps/num_actions)\n",
        "    policy[state][6] += (eps/num_actions)\n",
        "    policy[state][7] += (eps/num_actions)  \n",
        "    return policy"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def plotPolicy(grid, plot_size, width_factor=0.075):\n",
        "    cm = matplotlib.colors.ListedColormap(['black', 'white', 'blue', 'red', 'green', 'gold', 'lawngreen', 'grey', 'aqua', 'pink', 'brown'])\n",
        "    plt.figure(figsize=(plot_size, plot_size))\n",
        "    plt.pcolormesh(grid, edgecolors='black', cmap=cm, vmin=0.0, vmax=1.0)\n",
        "    plt.axes().set_aspect('equal')\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    \n",
        "    for s in range(env.side_length**2):\n",
        "        if (to_coord(env.side_length, s) in env.walls) or (to_coord(env.side_length,s)==env.door) or (to_coord(env.side_length,s) in env.obstacles):\n",
        "            continue\n",
        "        actions = agent.policy[s]\n",
        "        # print(\"s =\", s, \"actions =\", actions)\n",
        "        a = np.argmax(actions)\n",
        "        # print(\"s =\", s, \"actions =\", actions, \"a =\", a)\n",
        "        x,y = to_coord(env.side_length, s)\n",
        "        if a==0:\n",
        "            plt.arrow(x+0.5, y+0.7, 0.0, 0.8, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "        elif a==1:\n",
        "            plt.arrow(x+0.7, y+0.7, 0.7, 0.7, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "        elif a==2:\n",
        "            plt.arrow(x+0.7, y+0.5, 0.8, 0.0, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "        elif a==3:\n",
        "            plt.arrow(x+0.7, y+0.3, 0.7, -0.7, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "        elif a==4:\n",
        "            plt.arrow(x+0.5, y+0.3, 0.0, -0.8, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "        elif a==5:\n",
        "            plt.arrow(x+0.3, y+0.3, -0.7, -0.7, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "        elif a==6:\n",
        "            plt.arrow(x+0.3, y+0.5, -0.8, 0.0, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "        else:\n",
        "            plt.arrow(x+0.3, y+0.7, -0.7, 0.7, width=width_factor, head_width=2.5*width_factor, head_length=2*width_factor, length_includes_head=True, color='brown')\n",
        "    \n",
        "    \n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "0vHyu_ueGCrK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### SARSA"
      ],
      "metadata": {
        "id": "d2lQhEy1ytj3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def SARSA(NUM_ITER = 150):\n",
        "    Q = {}\n",
        "    for i in range(1,env.side_length-1):\n",
        "        for j in range(1,env.side_length-1):\n",
        "            if (i,j) in env.obstacles:\n",
        "                continue \n",
        "            u = to_node_idx(env.side_length, i, j)\n",
        "            Q[u] = {}\n",
        "            Q[u][0] = torch.rand(1)\n",
        "            Q[u][1] = torch.rand(1)\n",
        "            Q[u][2] = torch.rand(1)\n",
        "            Q[u][3] = torch.rand(1)\n",
        "            Q[u][4] = torch.rand(1)\n",
        "            Q[u][5] = torch.rand(1)\n",
        "            Q[u][6] = torch.rand(1)\n",
        "            Q[u][7] = torch.rand(1)\n",
        "    agent.initializePolicy()\n",
        "    R = getAllRewards()\n",
        "    R = R.reshape((R.size(1)))\n",
        "\n",
        "\n",
        "    cum_reward_S = []\n",
        "    epsilon = 0.98\n",
        "    alpha = 0.98\n",
        "    NUM_PLAYS = (env.side_length-2)**2\n",
        "\n",
        "    for iter in range(1,NUM_ITER+1):\n",
        "        agent.resetBuffer()\n",
        "        env.episode_length = 8\n",
        "        for x in range(1,env.side_length-1):\n",
        "            for y in range(1,env.side_length-1):\n",
        "                if (x,y) in env.obstacles:\n",
        "                    continue \n",
        "                env.init_x,env.init_y = x,y\n",
        "                agent.init_state = (x,y)\n",
        "                agent.reset()\n",
        "                env.resetTime()\n",
        "                ep = agent.playEpisode(env)\n",
        "\n",
        "        states = agent.experience[0]\n",
        "        actions = agent.experience[1]\n",
        "        rewards = agent.experience[2]\n",
        "        im_rewards = [[float(R[state]) for state in ep] for ep in states] # predicted immediate rewards\n",
        "\n",
        "        # Remove multiple rewards\n",
        "        for i,ep in enumerate(states):\n",
        "            visited_states = set()\n",
        "            for j,s in enumerate(ep):\n",
        "                if j==len(ep)-1:\n",
        "                    break\n",
        "                if s in visited_states:\n",
        "                    im_rewards[i][j+1] = 0.0\n",
        "                else:\n",
        "                    visited_states.add(s)\n",
        "        \n",
        "        for i,ep in enumerate(states):\n",
        "            for j in range(len(ep)-2):\n",
        "                s = states[i][j]\n",
        "                a = actions[i][j]\n",
        "                r = im_rewards[i][j+1]\n",
        "                sprime = states[i][j+1]\n",
        "                aprime = actions[i][j+1]\n",
        "                \n",
        "                vis_prev = False\n",
        "                for k in range(j):\n",
        "                    if states[i][k]==s and actions[i][k]==a:\n",
        "                        vis_prev = True\n",
        "                        break\n",
        "                if vis_prev:\n",
        "                    continue\n",
        "                \n",
        "                Q[s][a] += alpha*(r + Q[sprime][aprime] - Q[s][a])\n",
        "                agent.policy = improvePolicy(agent.policy, Q, s, epsilon)\n",
        "        \n",
        "        alpha *= 0.98\n",
        "        epsilon *= 0.98\n",
        "\n",
        "        rewards = torch.tensor(rewards).to(DEVICE)\n",
        "        cm = float(torch.sum(rewards))/float(NUM_PLAYS)\n",
        "        cum_reward_S.append(cm)\n",
        "\n",
        "        print(\"iter : \"+str(iter)+\" |  cum_reward : \"+str(cum_reward_S[-1]))\n",
        "\n",
        "    return cum_reward_S"
      ],
      "metadata": {
        "id": "jjPoJGZIyvnN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "cum_reward_S = SARSA()"
      ],
      "metadata": {
        "id": "p8xmw_B2yvkg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e501f21e-a503-400f-de1d-7944522595f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iter : 1 |  cum_reward : -0.29012345679012347\n",
            "iter : 2 |  cum_reward : -0.3533950617283951\n",
            "iter : 3 |  cum_reward : -0.3287037037037037\n",
            "iter : 4 |  cum_reward : -0.24537037037037038\n",
            "iter : 5 |  cum_reward : -0.2021604938271605\n",
            "iter : 6 |  cum_reward : -0.125\n",
            "iter : 7 |  cum_reward : -0.19290123456790123\n",
            "iter : 8 |  cum_reward : -0.08024691358024691\n",
            "iter : 9 |  cum_reward : -0.0787037037037037\n",
            "iter : 10 |  cum_reward : -0.12345679012345678\n",
            "iter : 11 |  cum_reward : -0.1419753086419753\n",
            "iter : 12 |  cum_reward : -0.007716049382716049\n",
            "iter : 13 |  cum_reward : -0.06944444444444445\n",
            "iter : 14 |  cum_reward : -0.009259259259259259\n",
            "iter : 15 |  cum_reward : 0.015432098765432098\n",
            "iter : 16 |  cum_reward : 0.05401234567901234\n",
            "iter : 17 |  cum_reward : 0.06481481481481481\n",
            "iter : 18 |  cum_reward : 0.12808641975308643\n",
            "iter : 19 |  cum_reward : 0.2037037037037037\n",
            "iter : 20 |  cum_reward : 0.17746913580246915\n",
            "iter : 21 |  cum_reward : 0.2808641975308642\n",
            "iter : 22 |  cum_reward : 0.18364197530864199\n",
            "iter : 23 |  cum_reward : 0.2638888888888889\n",
            "iter : 24 |  cum_reward : 0.26697530864197533\n",
            "iter : 25 |  cum_reward : 0.19598765432098766\n",
            "iter : 26 |  cum_reward : 0.3425925925925926\n",
            "iter : 27 |  cum_reward : 0.4537037037037037\n",
            "iter : 28 |  cum_reward : 0.3472222222222222\n",
            "iter : 29 |  cum_reward : 0.44135802469135804\n",
            "iter : 30 |  cum_reward : 0.5200617283950617\n",
            "iter : 31 |  cum_reward : 0.5416666666666666\n",
            "iter : 32 |  cum_reward : 0.5570987654320988\n",
            "iter : 33 |  cum_reward : 0.5509259259259259\n",
            "iter : 34 |  cum_reward : 0.48148148148148145\n",
            "iter : 35 |  cum_reward : 0.49228395061728397\n",
            "iter : 36 |  cum_reward : 0.5077160493827161\n",
            "iter : 37 |  cum_reward : 0.6327160493827161\n",
            "iter : 38 |  cum_reward : 0.7299382716049383\n",
            "iter : 39 |  cum_reward : 0.7021604938271605\n",
            "iter : 40 |  cum_reward : 0.6820987654320988\n",
            "iter : 41 |  cum_reward : 0.8194444444444444\n",
            "iter : 42 |  cum_reward : 0.7006172839506173\n",
            "iter : 43 |  cum_reward : 0.7654320987654321\n",
            "iter : 44 |  cum_reward : 0.8410493827160493\n",
            "iter : 45 |  cum_reward : 0.8225308641975309\n",
            "iter : 46 |  cum_reward : 0.808641975308642\n",
            "iter : 47 |  cum_reward : 0.8117283950617284\n",
            "iter : 48 |  cum_reward : 0.7453703703703703\n",
            "iter : 49 |  cum_reward : 0.9444444444444444\n",
            "iter : 50 |  cum_reward : 0.7947530864197531\n",
            "iter : 51 |  cum_reward : 0.9320987654320988\n",
            "iter : 52 |  cum_reward : 0.9753086419753086\n",
            "iter : 53 |  cum_reward : 0.9012345679012346\n",
            "iter : 54 |  cum_reward : 0.9907407407407407\n",
            "iter : 55 |  cum_reward : 0.9305555555555556\n",
            "iter : 56 |  cum_reward : 0.9182098765432098\n",
            "iter : 57 |  cum_reward : 1.0277777777777777\n",
            "iter : 58 |  cum_reward : 1.0324074074074074\n",
            "iter : 59 |  cum_reward : 0.9444444444444444\n",
            "iter : 60 |  cum_reward : 1.0046296296296295\n",
            "iter : 61 |  cum_reward : 1.0138888888888888\n",
            "iter : 62 |  cum_reward : 1.0030864197530864\n",
            "iter : 63 |  cum_reward : 1.0848765432098766\n",
            "iter : 64 |  cum_reward : 1.0401234567901234\n",
            "iter : 65 |  cum_reward : 1.0617283950617284\n",
            "iter : 66 |  cum_reward : 1.0339506172839505\n",
            "iter : 67 |  cum_reward : 1.0895061728395061\n",
            "iter : 68 |  cum_reward : 1.0524691358024691\n",
            "iter : 69 |  cum_reward : 1.0740740740740742\n",
            "iter : 70 |  cum_reward : 1.0709876543209877\n",
            "iter : 71 |  cum_reward : 1.0771604938271604\n",
            "iter : 72 |  cum_reward : 1.103395061728395\n",
            "iter : 73 |  cum_reward : 1.021604938271605\n",
            "iter : 74 |  cum_reward : 1.1790123456790123\n",
            "iter : 75 |  cum_reward : 1.1697530864197532\n",
            "iter : 76 |  cum_reward : 1.0617283950617284\n",
            "iter : 77 |  cum_reward : 1.212962962962963\n",
            "iter : 78 |  cum_reward : 1.212962962962963\n",
            "iter : 79 |  cum_reward : 1.2175925925925926\n",
            "iter : 80 |  cum_reward : 1.2145061728395061\n",
            "iter : 81 |  cum_reward : 1.2114197530864197\n",
            "iter : 82 |  cum_reward : 1.3055555555555556\n",
            "iter : 83 |  cum_reward : 1.271604938271605\n",
            "iter : 84 |  cum_reward : 1.2885802469135803\n",
            "iter : 85 |  cum_reward : 1.2376543209876543\n",
            "iter : 86 |  cum_reward : 1.2993827160493827\n",
            "iter : 87 |  cum_reward : 1.2901234567901234\n",
            "iter : 88 |  cum_reward : 1.3302469135802468\n",
            "iter : 89 |  cum_reward : 1.2777777777777777\n",
            "iter : 90 |  cum_reward : 1.3549382716049383\n",
            "iter : 91 |  cum_reward : 1.3518518518518519\n",
            "iter : 92 |  cum_reward : 1.3472222222222223\n",
            "iter : 93 |  cum_reward : 1.3271604938271604\n",
            "iter : 94 |  cum_reward : 1.3302469135802468\n",
            "iter : 95 |  cum_reward : 1.3611111111111112\n",
            "iter : 96 |  cum_reward : 1.2978395061728396\n",
            "iter : 97 |  cum_reward : 1.3194444444444444\n",
            "iter : 98 |  cum_reward : 1.308641975308642\n",
            "iter : 99 |  cum_reward : 1.337962962962963\n",
            "iter : 100 |  cum_reward : 1.3580246913580247\n",
            "iter : 101 |  cum_reward : 1.3935185185185186\n",
            "iter : 102 |  cum_reward : 1.3179012345679013\n",
            "iter : 103 |  cum_reward : 1.404320987654321\n",
            "iter : 104 |  cum_reward : 1.337962962962963\n",
            "iter : 105 |  cum_reward : 1.3935185185185186\n",
            "iter : 106 |  cum_reward : 1.4089506172839505\n",
            "iter : 107 |  cum_reward : 1.3888888888888888\n",
            "iter : 108 |  cum_reward : 1.4367283950617284\n",
            "iter : 109 |  cum_reward : 1.4027777777777777\n",
            "iter : 110 |  cum_reward : 1.4027777777777777\n",
            "iter : 111 |  cum_reward : 1.4027777777777777\n",
            "iter : 112 |  cum_reward : 1.4305555555555556\n",
            "iter : 113 |  cum_reward : 1.4228395061728396\n",
            "iter : 114 |  cum_reward : 1.3919753086419753\n",
            "iter : 115 |  cum_reward : 1.4012345679012346\n",
            "iter : 116 |  cum_reward : 1.4243827160493827\n",
            "iter : 117 |  cum_reward : 1.4768518518518519\n",
            "iter : 118 |  cum_reward : 1.4274691358024691\n",
            "iter : 119 |  cum_reward : 1.4737654320987654\n",
            "iter : 120 |  cum_reward : 1.4197530864197532\n",
            "iter : 121 |  cum_reward : 1.4243827160493827\n",
            "iter : 122 |  cum_reward : 1.4475308641975309\n",
            "iter : 123 |  cum_reward : 1.4398148148148149\n",
            "iter : 124 |  cum_reward : 1.4567901234567902\n",
            "iter : 125 |  cum_reward : 1.4537037037037037\n",
            "iter : 126 |  cum_reward : 1.4135802469135803\n",
            "iter : 127 |  cum_reward : 1.4398148148148149\n",
            "iter : 128 |  cum_reward : 1.4475308641975309\n",
            "iter : 129 |  cum_reward : 1.5061728395061729\n",
            "iter : 130 |  cum_reward : 1.4351851851851851\n",
            "iter : 131 |  cum_reward : 1.4753086419753085\n",
            "iter : 132 |  cum_reward : 1.4891975308641976\n",
            "iter : 133 |  cum_reward : 1.470679012345679\n",
            "iter : 134 |  cum_reward : 1.4861111111111112\n",
            "iter : 135 |  cum_reward : 1.4814814814814814\n",
            "iter : 136 |  cum_reward : 1.4290123456790123\n",
            "iter : 137 |  cum_reward : 1.433641975308642\n",
            "iter : 138 |  cum_reward : 1.4768518518518519\n",
            "iter : 139 |  cum_reward : 1.4891975308641976\n",
            "iter : 140 |  cum_reward : 1.4552469135802468\n",
            "iter : 141 |  cum_reward : 1.4645061728395061\n",
            "iter : 142 |  cum_reward : 1.5200617283950617\n",
            "iter : 143 |  cum_reward : 1.4907407407407407\n",
            "iter : 144 |  cum_reward : 1.4614197530864197\n",
            "iter : 145 |  cum_reward : 1.4969135802469136\n",
            "iter : 146 |  cum_reward : 1.4969135802469136\n",
            "iter : 147 |  cum_reward : 1.5154320987654322\n",
            "iter : 148 |  cum_reward : 1.5\n",
            "iter : 149 |  cum_reward : 1.5277777777777777\n",
            "iter : 150 |  cum_reward : 1.4969135802469136\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plotPolicy(env.getGrid(), env.plot_size)"
      ],
      "metadata": {
        "id": "uUDMpq-Fy1zG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 578
        },
        "outputId": "4ebd2d70-bb1c-4b6d-f5cd-31ff9a31a2f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "1OXxmcLE65FX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "6om8xnKLva7L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "m9z5vqKrtqOQ"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "BTP2_Ex3B.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}