SARSA with Tile Coding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "bfeb29c19452c8f782e787e746422cae",
     "grade": false,
     "grade_id": "cell-6e2d08d53786c408",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "# Assignment 3: Function Approximation and Control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "bc8f8a3eff0506f5f2adbb15d865a6f8",
     "grade": false,
     "grade_id": "cell-c0aa3738f85c68a6",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Welcome to Assignment 3. In this notebook you will learn how to:\n",
    "- Use function approximation in the control setting\n",
    "- Implement the Sarsa algorithm using tile coding\n",
    "- Compare three settings for tile coding to see their effect on our agent\n",
    "\n",
    "As with the rest of the notebooks do not import additional libraries or adjust grading cells as this will break the grader.\n",
    "\n",
    "MAKE SURE TO RUN ALL OF THE CELLS SO THE GRADER GETS THE OUTPUT IT NEEDS\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9d89a1172d798eea73c3f94e84b19a80",
     "grade": false,
     "grade_id": "cell-3e99c32936b1780b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Import Necessary Libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tiles3 as tc\n",
    "from rl_glue import RLGlue\n",
    "from agent import BaseAgent\n",
    "from utils import argmax\n",
    "import mountaincar_env\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "b4b89842d59f53a0397404188fea8a68",
     "grade": false,
     "grade_id": "cell-0c184d76dab0d615",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "In the above cell, we import the libraries we need for this assignment. You may have noticed that we import mountaincar_env. This is the __Mountain Car Task__ introduced in [Section 10.1 of the textbook](http://www.incompleteideas.net/book/RLbook2018.pdf#page=267). The task is for an under powered car to make it to the top of a hill:\n",
    "![Mountain Car](mountaincar.png \"Mountain Car\")\n",
    "The car is under-powered so the agent needs to learn to rock back and forth to get enough momentum to reach the goal. At each time step the agent receives from the environment its current velocity (a float between -0.07 and 0.07), and it's current position (a float between -1.2 and 0.5). Because our state is continuous there are a potentially infinite number of states that our agent could be in. We need a function approximation method to help the agent deal with this. In this notebook we will use tile coding. We provide a tile coding implementation for you to use, imported above with tiles3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ec2c6de4858e1844bbba0fb965fb1697",
     "grade": false,
     "grade_id": "cell-abeb1cf4c7319766",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Section 0: Tile Coding Helper Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9948acdae6f3a64b7c81cf049ebb80a2",
     "grade": false,
     "grade_id": "cell-6b462acd2d7d2b79",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To begin we are going to build a tile coding class for our Sarsa agent that will make it easier to make calls to our tile coder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "3ead2ccf72a2be17e6781d5b76e84219",
     "grade": false,
     "grade_id": "cell-85d6085e6342eb1c",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Tile Coding Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "50b0abf997f87549fd27944b04e5b57c",
     "grade": false,
     "grade_id": "cell-2067725dbeb55d8b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Tile coding is introduced in [Section 9.5.4 of the textbook](http://www.incompleteideas.net/book/RLbook2018.pdf#page=239) of the textbook as a way to create features that can both provide good generalization and discrimination. It consists of multiple overlapping tilings, where each tiling is a partitioning of the space into tiles.\n",
    "![Tile Coding](tilecoding.png \"Tile Coding\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "810ec33572588560507256351c37be9d",
     "grade": false,
     "grade_id": "cell-7fc517d0f2a4618e",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To help keep our agent code clean we are going to make a function specific for tile coding for our Mountain Car environment. To help we are going to use the Tiles3 library. This is a Python 3 implementation of the tile coder. To start take a look at the documentation: [Tiles3 documentation](http://incompleteideas.net/tiles/tiles3.html)\n",
    "To get the tile coder working we need to implement a few pieces:\n",
    "- First: create an index hash table - this is done for you in the init function using tc.IHT.\n",
    "- Second is to scale the inputs for the tile coder based on the number of tiles and the range of values each input could take. The tile coder needs to take in a number in range [0, 1], or scaled to be [0, 1] * num_tiles. For more on this refer to the [Tiles3 documentation](http://incompleteideas.net/tiles/tiles3.html).\n",
    "- Finally we call tc.tiles to get the active tiles back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "960c0a3aaa33badde927b45c7a4ebb96",
     "grade": false,
     "grade_id": "cell-12821f87b5c813b2",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Tile Coding Function [Graded]\n",
    "class MountainCarTileCoder:\n",
    "    def __init__(self, iht_size=4096, num_tilings=8, num_tiles=8):\n",
    "        \"\"\"\n",
    "        Initializes the MountainCar Tile Coder\n",
    "        Initializers:\n",
    "        iht_size -- int, the size of the index hash table, typically a power of 2\n",
    "        num_tilings -- int, the number of tilings\n",
    "        num_tiles -- int, the number of tiles. Here both the width and height of the\n",
    "                     tile coder are the same\n",
    "        Class Variables:\n",
    "        self.iht -- tc.IHT, the index hash table that the tile coder will use\n",
    "        self.num_tilings -- int, the number of tilings the tile coder will use\n",
    "        self.num_tiles -- int, the number of tiles the tile coder will use\n",
    "        \"\"\"\n",
    "        self.iht = tc.IHT(iht_size)\n",
    "        self.num_tilings = num_tilings\n",
    "        self.num_tiles = num_tiles\n",
    "    \n",
    "    def get_tiles(self, position, velocity):\n",
    "        \"\"\"\n",
    "        Takes in a position and velocity from the mountaincar environment\n",
    "        and returns a numpy array of active tiles.\n",
    "        \n",
    "        Arguments:\n",
    "        position -- float, the position of the agent between -1.2 and 0.5\n",
    "        velocity -- float, the velocity of the agent between -0.07 and 0.07\n",
    "        returns:\n",
    "        tiles - np.array, active tiles\n",
    "        \"\"\"\n",
    "        # Set the max and min of position and velocity to scale the input\n",
    "        # POSITION_MIN\n",
    "        # POSITION_MAX\n",
    "        # VELOCITY_MIN\n",
    "        # VELOCITY_MAX\n",
    "        ### START CODE HERE ###\n",
    "        position_min = -1.2\n",
    "        position_max = 0.5\n",
    "        velocity_min = -0.07\n",
    "        velocity_max = 0.07\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Use the ranges above and self.num_tiles to set position_scale and velocity_scale\n",
    "        # position_scale = number of tiles / position range\n",
    "        # velocity_scale = number of tiles / velocity range\n",
    "        \n",
    "        # Scale position and velocity by multiplying the inputs of each by their scale\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        position_scale = self.num_tiles / (position_max - position_min)\n",
    "        velocity_scale = self.num_tiles / (velocity_max - velocity_min)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # get the tiles using tc.tiles, with self.iht, self.num_tilings and [scaled position, scaled velocity]\n",
    "        # nothing to implment here\n",
    "        tiles = tc.tiles(self.iht, self.num_tilings, [position * position_scale, \n",
    "                                                      velocity * velocity_scale])\n",
    "        \n",
    "        return np.array(tiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "2f9114c9e8fe820a8d131b87e4c589a6",
     "grade": false,
     "grade_id": "cell-2c8b58b5dc63cc52",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your results:\n",
      "[0 1 2 3 4 5 6 7]\n",
      "[ 8  9 10 11 12 13 14 15]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "[ 0 24  2  3  4  5  6  7]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "\n",
      "Expected results:\n",
      "[0 1 2 3 4 5 6 7]\n",
      "[ 8  9 10 11 12 13 14 15]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "[ 0 24  2  3  4  5  6  7]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# [DO NOT CHANGE]\n",
    "tests = [[-1.0, 0.01], [0.1, -0.01], [0.2, -0.05], [-1.0, 0.011], [0.2, -0.05]]\n",
    "\n",
    "mctc = MountainCarTileCoder(iht_size=1024, num_tilings=8, num_tiles=8)\n",
    "\n",
    "t = []\n",
    "for test in tests:\n",
    "    position, velocity = test\n",
    "    tiles = mctc.get_tiles(position=position, velocity=velocity)\n",
    "    t.append(tiles)\n",
    "\n",
    "print(\"Your results:\")\n",
    "for tiles in t:\n",
    "    print(tiles)\n",
    "\n",
    "print()\n",
    "print(\"Expected results:\")\n",
    "expected = \"\"\"[0 1 2 3 4 5 6 7]\n",
    "[ 8  9 10 11 12 13 14 15]\n",
    "[16 17 18 19 20 21 22 23]\n",
    "[ 0 24  2  3  4  5  6  7]\n",
    "[16 17 18 19 20 21 22 23]\n",
    "\"\"\"\n",
    "print(expected)\n",
    "\n",
    "np.random.seed(1)\n",
    "mctc_test = MountainCarTileCoder(iht_size=1024, num_tilings=8, num_tiles=8)\n",
    "test = [mctc_test.get_tiles(np.random.uniform(-1.2, 0.5), np.random.uniform(-0.07, 0.07)) for _ in range(10)]\n",
    "np.save(\"tiles_test\", test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "fdaa393fe01b7bebe2ff44aeabc1a233",
     "grade": false,
     "grade_id": "cell-b647e597fb7ee2e4",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Section 1: Sarsa Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d8b0c1c1cab5bd89cc9479e3faad7539",
     "grade": false,
     "grade_id": "cell-bc36b07292c6751a",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We are now going to use the functions that we just created to implement the Sarsa algorithm. Recall from class that Sarsa stands for State, Action, Reward, State, Action.\n",
    "\n",
    "For this case we have given you an argmax function similar to what you wrote back in Course 1 Assignment 1. Recall, this is different than the argmax function that is used by numpy, which returns the first index of a maximum value. We want our argmax function to arbitrarily break ties, which is what the imported argmax function does. The given argmax function takes in an array of values and returns an int of the chosen action: \n",
    "argmax(action values)\n",
    "\n",
    "There are multiple ways that we can deal with actions for the tile coder. Here we are going to use one simple method - make the size of the weight vector equal to (iht_size, num_actions). This will give us one weight vector for each action and one weight for each tile.\n",
    "\n",
    "Use the above function to help fill in select_action, agent_start, agent_step, and agent_end.\n",
    "\n",
    "Hints:\n",
    "\n",
    "1) The tile coder returns a list of active indexes (e.g. [1, 12, 22]). You can index a numpy array using an array of values - this will return an array of the values at each of those indices. So in order to get the value of a state we can index our weight vector using the action and the array of tiles that the tile coder returns:\n",
    "\n",
    "```self.w[action][active_tiles]```\n",
    "\n",
    "This will give us an array of values, one for each active tile, and we sum the result to get the value of that state-action pair.\n",
    "\n",
    "2) In the case of a binary feature vector (such as the tile coder), the derivative is 1 at each of the active tiles, and zero otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "c899864c5d5422ec74315ab7ec2ae092",
     "grade": false,
     "grade_id": "cell-f01df3aacf5a9d4b",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# SARSA\n",
    "class SarsaAgent(BaseAgent):\n",
    "    \"\"\"\n",
    "    Initialization of Sarsa Agent. All values are set to None so they can\n",
    "    be initialized in the agent_init method.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.last_action = None\n",
    "        self.last_state = None\n",
    "        self.epsilon = None\n",
    "        self.gamma = None\n",
    "        self.iht_size = None\n",
    "        self.w = None\n",
    "        self.alpha = None\n",
    "        self.num_tilings = None\n",
    "        self.num_tiles = None\n",
    "        self.mctc = None\n",
    "        self.initial_weights = None\n",
    "        self.num_actions = None\n",
    "        self.previous_tiles = None\n",
    "\n",
    "    def agent_init(self, agent_info={}):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\"\"\"\n",
    "        self.num_tilings = agent_info.get(\"num_tilings\", 8)\n",
    "        self.num_tiles = agent_info.get(\"num_tiles\", 8)\n",
    "        self.iht_size = agent_info.get(\"iht_size\", 4096)\n",
    "        self.epsilon = agent_info.get(\"epsilon\", 0.0)\n",
    "        self.gamma = agent_info.get(\"gamma\", 1.0)\n",
    "        self.alpha = agent_info.get(\"alpha\", 0.5) / self.num_tilings\n",
    "        self.initial_weights = agent_info.get(\"initial_weights\", 0.0)\n",
    "        self.num_actions = agent_info.get(\"num_actions\", 3)\n",
    "        \n",
    "        # We initialize self.w to three times the iht_size. Recall this is because\n",
    "        # we need to have one set of weights for each action.\n",
    "        self.w = np.ones((self.num_actions, self.iht_size)) * self.initial_weights\n",
    "        \n",
    "        # We initialize self.mctc to the mountaincar verions of the \n",
    "        # tile coder that we created\n",
    "        self.tc = MountainCarTileCoder(iht_size=self.iht_size, \n",
    "                                         num_tilings=self.num_tilings, \n",
    "                                         num_tiles=self.num_tiles)\n",
    "\n",
    "    def select_action(self, tiles):\n",
    "        \"\"\"\n",
    "        Selects an action using epsilon greedy\n",
    "        Args:\n",
    "        tiles - np.array, an array of active tiles\n",
    "        Returns:\n",
    "        (chosen_action, action_value) - (int, float), tuple of the chosen action\n",
    "                                        and it's value\n",
    "        \"\"\"\n",
    "        action_values = []\n",
    "        chosen_action = None\n",
    "        \n",
    "        # First loop through the weights of each action and populate action_values\n",
    "        # with the action value for each action and tiles instance\n",
    "        \n",
    "        # Use np.random.random to decide if an exploritory action should be taken\n",
    "        # and set chosen_action to a random action if it is\n",
    "        # Otherwise choose the greedy action using the given argmax \n",
    "        # function and the action values (don't use numpy's armax)\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        for action_value in self.w:\n",
    "            action_values.append(sum(action_value[tiles]))\n",
    "        if np.random.random() < self.epsilon:\n",
    "            chosen_action = np.random.choice(self.num_actions)\n",
    "        else:\n",
    "            chosen_action = argmax(action_values)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        return chosen_action, action_values[chosen_action]\n",
    "    \n",
    "    def agent_start(self, state):\n",
    "        \"\"\"The first method called when the experiment starts, called after\n",
    "        the environment starts.\n",
    "        Args:\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's evn_start function.\n",
    "        Returns:\n",
    "            The first action the agent takes.\n",
    "        \"\"\"\n",
    "        position, velocity = state\n",
    "        \n",
    "        # Use self.tc to set active_tiles using position and velocity\n",
    "        # set current_action to the epsilon greedy chosen action using\n",
    "        # the select_action function above with the active tiles\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        active_tiles = self.tc.get_tiles(position, velocity)\n",
    "        current_action, _ = self.select_action(active_tiles)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        self.last_action = current_action\n",
    "        self.previous_tiles = np.copy(active_tiles)\n",
    "        return self.last_action\n",
    "\n",
    "    def agent_step(self, reward, state):\n",
    "        \"\"\"A step taken by the agent.\n",
    "        Args:\n",
    "            reward (float): the reward received for taking the last action taken\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's step based, where the agent ended up after the\n",
    "                last step\n",
    "        Returns:\n",
    "            The action the agent is taking.\n",
    "        \"\"\"\n",
    "        # choose the action here\n",
    "        position, velocity = state\n",
    "        \n",
    "        # Use self.tc to set active_tiles using position and velocity\n",
    "        # set current_action and action_value to the epsilon greedy chosen action using\n",
    "        # the select_action function above with the active tiles\n",
    "        \n",
    "        # Update self.w at self.previous_tiles and self.previous action\n",
    "        # using the reward, action_value, self.gamma, self.w,\n",
    "        # self.alpha, and the Sarsa update from the textbook\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        active_tiles = self.tc.get_tiles(position = position, velocity = velocity)\n",
    "        current_action, action_value = self.select_action(active_tiles)\n",
    "        delta = reward + self.gamma * action_value - np.sum(self.w[self.last_action][self.previous_tiles])\n",
    "        self.w[self.last_action][self.previous_tiles] += self.alpha * delta\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        self.last_action = current_action\n",
    "        self.previous_tiles = np.copy(active_tiles)\n",
    "        return self.last_action\n",
    "\n",
    "    def agent_end(self, reward):\n",
    "        \"\"\"Run when the agent terminates.\n",
    "        Args:\n",
    "            reward (float): the reward the agent received for entering the\n",
    "                terminal state.\n",
    "        \"\"\"\n",
    "        # Update self.w at self.previous_tiles and self.previous action\n",
    "        # using the reward, self.gamma, self.w,\n",
    "        # self.alpha, and the Sarsa update from the textbook\n",
    "        # Hint - there is no action_value used here because this is the end\n",
    "        # of the episode.\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        delta = reward - np.sum(self.w[self.last_action][self.previous_tiles])\n",
    "        self.w[self.last_action][self.previous_tiles] += self.alpha * delta\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "    def agent_cleanup(self):\n",
    "        \"\"\"Cleanup done after the agent ends.\"\"\"\n",
    "        pass\n",
    "\n",
    "    def agent_message(self, message):\n",
    "        \"\"\"A function used to pass information from the agent to the experiment.\n",
    "        Args:\n",
    "            message: The message passed to the agent.\n",
    "        Returns:\n",
    "            The response (or answer) to the message.\n",
    "        \"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "cd2e581d58b48f8be57ecd190b2b6e6a",
     "grade": false,
     "grade_id": "cell-4363d332fa1b0f96",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14490\n",
      "Expected value\n",
      "(2, 15)\n",
      "Your value\n",
      "(2, 15)\n"
     ]
    }
   ],
   "source": [
    "# Test Epsilon Greedy Function [DO NOT CHANGE]\n",
    "agent = SarsaAgent()\n",
    "agent.agent_init({\"epsilon\": 0.1})\n",
    "agent.w = np.array([np.array([1, 2, 3]), np.array([4, 5, 6]), np.array([7, 8, 9])])\n",
    "\n",
    "total = 0\n",
    "for i in range(1000):\n",
    "    chosen_action, action_value = agent.select_action(np.array([0,1]))\n",
    "    total += action_value\n",
    "print(total)\n",
    "assert total < 15000, \"Check that you are not always choosing the best action\"\n",
    "\n",
    "np.save(\"epsilon_test\", total)\n",
    "\n",
    "agent = SarsaAgent()\n",
    "agent.agent_init({\"epsilon\": 0.0})\n",
    "agent.w = np.array([np.array([1, 2, 3]), np.array([4, 5, 6]), np.array([7, 8, 9])])\n",
    "\n",
    "chosen_action, action_value = agent.select_action(np.array([0,1]))\n",
    "print(\"Expected value\")\n",
    "print(\"(2, 15)\")\n",
    "\n",
    "print(\"Your value\")\n",
    "print((chosen_action, action_value))\n",
    "\n",
    "np.save(\"egreedy_test\", (chosen_action, action_value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "8082fe078300cb738d2dd10f590a3535",
     "grade": false,
     "grade_id": "cell-aa40398d933320db",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUN: 0\n",
      "RUN: 5\n",
      "Run time: 9.875396251678467\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test Sarsa Agent [DO NOT CHANGE]\n",
    "num_runs = 10\n",
    "num_episodes = 50\n",
    "env_info = {\"num_tiles\": 8, \"num_tilings\": 8}\n",
    "agent_info = {}\n",
    "all_steps = []\n",
    "\n",
    "agent = SarsaAgent\n",
    "env = mountaincar_env.Environment\n",
    "start = time.time()\n",
    "\n",
    "for run in range(num_runs):\n",
    "    if run % 5 == 0:\n",
    "        print(\"RUN: {}\".format(run))\n",
    "\n",
    "    rl_glue = RLGlue(env, agent)\n",
    "    rl_glue.rl_init(agent_info, env_info)\n",
    "    steps_per_episode = []\n",
    "\n",
    "    for episode in range(num_episodes):\n",
    "        rl_glue.rl_episode(15000)\n",
    "        steps_per_episode.append(rl_glue.num_steps)\n",
    "\n",
    "    all_steps.append(np.array(steps_per_episode))\n",
    "\n",
    "print(\"Run time: {}\".format(time.time() - start))\n",
    "\n",
    "plt.plot(np.mean(np.array(all_steps), axis=0))\n",
    "np.save(\"sarsa_test\", np.array(all_steps))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "76a454920dcb6dd3d10d811a2f4dfa21",
     "grade": false,
     "grade_id": "cell-25c387a04d2d325f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "The learning rate of your agent should look similar to ours, though it will not look exactly the same.If there are some spikey points that is okay. Due to stochasticity,  a few episodes may have taken much longer, causing some spikes in the plot. The trend of the line should be similar, though, generally decreasing to about 200 steps per run.\n",
    "![alt text](sarsa_agent_initial.png \"Logo Title Text 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "59a8c32add9b94d547093defbc0958cf",
     "grade": false,
     "grade_id": "cell-b8423d7852d12941",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "This result was using 8 tilings with 8x8 tiles on each. Let's see if we can do better, and what different tilings look like. We will also text 2 tilings of 16x16 and 4 tilings of 32x32. These three choices produce the same number of features (512), but distributed quite differently. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "da19e771d808db89cb738f0c84fcecca",
     "grade": false,
     "grade_id": "cell-779d7aea26f74686",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.25\n",
      "Run Time: 47.07899856567383\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.015625\n",
      "Run Time: 33.26818799972534\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.0625\n",
      "Run Time: 29.26741051673889\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f87f032a780>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare the three\n",
    "num_runs = 20\n",
    "num_episodes = 100\n",
    "env_info = {}\n",
    "\n",
    "agent_runs = []\n",
    "# alphas = [0.2, 0.4, 0.5, 1.0]\n",
    "alphas = [0.5]\n",
    "agent_info_options = [{\"num_tiles\": 16, \"num_tilings\": 2, \"alpha\": 0.5},\n",
    "                      {\"num_tiles\": 4, \"num_tilings\": 32, \"alpha\": 0.5},\n",
    "                      {\"num_tiles\": 8, \"num_tilings\": 8, \"alpha\": 0.5}]\n",
    "agent_info_options = [{\"num_tiles\" : agent[\"num_tiles\"], \n",
    "                       \"num_tilings\": agent[\"num_tilings\"],\n",
    "                       \"alpha\" : alpha} for agent in agent_info_options for alpha in alphas]\n",
    "\n",
    "agent = SarsaAgent\n",
    "env = mountaincar_env.Environment\n",
    "for agent_info in agent_info_options:\n",
    "    all_steps = []\n",
    "    start = time.time()\n",
    "    for run in range(num_runs):\n",
    "        if run % 5 == 0:\n",
    "            print(\"RUN: {}\".format(run))\n",
    "        env = mountaincar_env.Environment\n",
    "        \n",
    "        rl_glue = RLGlue(env, agent)\n",
    "        rl_glue.rl_init(agent_info, env_info)\n",
    "        steps_per_episode = []\n",
    "\n",
    "        for episode in range(num_episodes):\n",
    "            rl_glue.rl_episode(15000)\n",
    "            steps_per_episode.append(rl_glue.num_steps)\n",
    "        all_steps.append(np.array(steps_per_episode))\n",
    "    \n",
    "    agent_runs.append(np.mean(np.array(all_steps), axis=0))\n",
    "    print(rl_glue.agent.alpha)\n",
    "    print(\"Run Time: {}\".format(time.time() - start))\n",
    "\n",
    "plt.figure(figsize=(15, 10), dpi= 80, facecolor='w', edgecolor='k')\n",
    "plt.plot(np.array(agent_runs).T)\n",
    "plt.xlabel(\"Episode\")\n",
    "plt.ylabel(\"Steps Per Episode\")\n",
    "plt.yscale(\"linear\")\n",
    "plt.ylim(0, 1000)\n",
    "plt.legend([\"num_tiles: {}, num_tilings: {}, alpha: {}\".format(agent_info[\"num_tiles\"], \n",
    "                                                               agent_info[\"num_tilings\"],\n",
    "                                                               agent_info[\"alpha\"])\n",
    "            for agent_info in agent_info_options])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6038f4c142bec2a4e78e32ddf9c249de",
     "grade": false,
     "grade_id": "cell-b7e2f943ac40b395",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Here we can see that using 32 tilings and 4 x 4 tiles does a little better than 8 tilings with 8x8 tiles. Both seem to do much better than using 2 tilings, with 16 x 16 tiles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "63a8d309f64550844d8d8669796da9e6",
     "grade": false,
     "grade_id": "cell-279952a048a11f2a",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Section 3: Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d2f0a01598313c64677f7ea426cad9cc",
     "grade": false,
     "grade_id": "cell-a2e2660173b7334f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Congratulations! You have learned how to implement a control agent using function approximation. In this notebook you learned how to:\n",
    "\n",
    "- Use function approximation in the control setting\n",
    "- Implement the Sarsa algorithm using tile coding\n",
    "- Compare three settings for tile coding to see their effect on our agent"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "coursera": {
   "course_slug": "prediction-control-function-approximation",
   "graded_item_id": "N1YGC",
   "launcher_item_id": "UJo5o"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}