Function_Approximation_and_Control_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f91befe560efc058705938cd516c0cbf",
     "grade": false,
     "grade_id": "cell-d7aa7f0ccfbe6764",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Assignment 3: Function Approximation and Control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8367cb0523270ba9ea53fc9a4e237294",
     "grade": false,
     "grade_id": "cell-4aea2284d1d0ee5b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": 1,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c3bf50501352096f22c673e3f781ca93",
     "grade": false,
     "grade_id": "cell-68be8d91fe7fd3dd",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Import Necessary Libraries\n",
    "import numpy as np\n",
    "import itertools\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": {
     "cell_type": "markdown",
     "checksum": "2197641d6402383eb671432ec4de8822",
     "grade": false,
     "grade_id": "cell-631c7b26d3b5c04b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": {
     "cell_type": "markdown",
     "checksum": "2e2e288fe7f1840098d7b6ada17f505e",
     "grade": false,
     "grade_id": "cell-bbe24ca993c1b297",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Section 0: Tile Coding Helper Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "104fa1489f8107d5d841e786c2fb27b0",
     "grade": false,
     "grade_id": "cell-00c3ac7f568f6166",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": {
     "cell_type": "markdown",
     "checksum": "6cd7184cfa3356edd1720b8fd51ed2c9",
     "grade": false,
     "grade_id": "cell-97d06568c071d9cc",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Tile Coding Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a88c06a2dc95f3c24dafc6896575fec7",
     "grade": false,
     "grade_id": "cell-cdfcd9285845ad67",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": {
     "cell_type": "markdown",
     "checksum": "fbbce233f230a1d8be56f3da3f9b74ea",
     "grade": false,
     "grade_id": "cell-a4b22741e31308d4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": 2,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1f9f621377db1b80790b2203fdf266a5",
     "grade": false,
     "grade_id": "cell-5d4b035fb7a71186",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\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",
    "        # Use the ranges above and self.num_tiles to scale position and velocity to the range [0, 1]\n",
    "        # then multiply that range with self.num_tiles so it scales from [0, num_tiles]\n",
    "        \n",
    "        position_scaled = 0\n",
    "        velocity_scaled = 0\n",
    "        \n",
    "        # ----------------\n",
    "        position_scaled = self.num_tiles * (position - -1.2) / (0.5 - -1.2)\n",
    "        velocity_scaled = self.num_tiles * (velocity - -0.07) / (0.07 - -0.07)\n",
    "        # ----------------\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_scaled, velocity_scaled])\n",
    "        \n",
    "        return np.array(tiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "734698474359c7766846c7d26ffbaf67",
     "grade": true,
     "grade_id": "cell-beac2fa8ff1ef94e",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "# create a range of positions and velocities to test\n",
    "# then test every element in the cross-product between these lists\n",
    "pos_tests = np.linspace(-1.2, 0.5, num=5)\n",
    "vel_tests = np.linspace(-0.07, 0.07, num=5)\n",
    "tests = list(itertools.product(pos_tests, vel_tests))\n",
    "\n",
    "mctc = MountainCarTileCoder(iht_size=1024, num_tilings=8, num_tiles=2)\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",
    "expected = [\n",
    "    [0, 1, 2, 3, 4, 5, 6, 7],\n",
    "    [0, 1, 8, 3, 9, 10, 6, 11],\n",
    "    [12, 13, 8, 14, 9, 10, 15, 11],\n",
    "    [12, 13, 16, 14, 17, 18, 15, 19],\n",
    "    [20, 21, 16, 22, 17, 18, 23, 19],\n",
    "    [0, 1, 2, 3, 24, 25, 26, 27],\n",
    "    [0, 1, 8, 3, 28, 29, 26, 30],\n",
    "    [12, 13, 8, 14, 28, 29, 31, 30],\n",
    "    [12, 13, 16, 14, 32, 33, 31, 34],\n",
    "    [20, 21, 16, 22, 32, 33, 35, 34],\n",
    "    [36, 37, 38, 39, 24, 25, 26, 27],\n",
    "    [36, 37, 40, 39, 28, 29, 26, 30],\n",
    "    [41, 42, 40, 43, 28, 29, 31, 30],\n",
    "    [41, 42, 44, 43, 32, 33, 31, 34],\n",
    "    [45, 46, 44, 47, 32, 33, 35, 34],\n",
    "    [36, 37, 38, 39, 48, 49, 50, 51],\n",
    "    [36, 37, 40, 39, 52, 53, 50, 54],\n",
    "    [41, 42, 40, 43, 52, 53, 55, 54],\n",
    "    [41, 42, 44, 43, 56, 57, 55, 58],\n",
    "    [45, 46, 44, 47, 56, 57, 59, 58],\n",
    "    [60, 61, 62, 63, 48, 49, 50, 51],\n",
    "    [60, 61, 64, 63, 52, 53, 50, 54],\n",
    "    [65, 66, 64, 67, 52, 53, 55, 54],\n",
    "    [65, 66, 68, 67, 56, 57, 55, 58],\n",
    "    [69, 70, 68, 71, 56, 57, 59, 58],\n",
    "]\n",
    "assert np.all(expected == np.array(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "089f4dcbbff9c5efec3476ee8e8ba1c9",
     "grade": false,
     "grade_id": "cell-5191224461a0f3b5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Section 1: Sarsa Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f0c661efa74205b51539471c4285118a",
     "grade": false,
     "grade_id": "cell-5db2a3c6722ea91c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": 7,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c1dd6c5e729fc638934b67090e2c92a0",
     "grade": false,
     "grade_id": "cell-50303440b2e9be74",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# -----------\n",
    "# Graded Cell\n",
    "# -----------\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",
    "        # ----------------\n",
    "        for i in range(self.num_actions):\n",
    "            weights = self.w[i][tiles]\n",
    "            action_values.append(np.sum(weights))\n",
    "        \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",
    "        \n",
    "        # ----------------\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",
    "        # ----------------\n",
    "        active_tiles = self.tc.get_tiles(position, velocity)\n",
    "        current_action, _ = self.select_action(active_tiles)\n",
    "        \n",
    "        # ----------------\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",
    "        # ----------------\n",
    "        active_tiles = self.tc.get_tiles(position, velocity)\n",
    "        current_action, _ = self.select_action(active_tiles)\n",
    "        \n",
    "        # ----------------\n",
    "        \n",
    "        target = reward + self.gamma*np.sum(self.w[current_action][active_tiles])\n",
    "        self.w[self.last_action][self.previous_tiles] += self.alpha*(target - np.sum(self.w[self.last_action][self.previous_tiles]))\n",
    "        \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",
    "        # ----------------\n",
    "        last_action_value = self.w[self.last_action][self.previous_tiles].sum()\n",
    "        delta = reward - last_action_value\n",
    "        grad = np.zeros_like(self.w)\n",
    "        grad[self.last_action][self.previous_tiles] = 1\n",
    "        self.w += self.alpha * delta * grad\n",
    "        \n",
    "        # ----------------\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": 8,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "692ac428d5e59bae3f74450657877a50",
     "grade": true,
     "grade_id": "cell-0cf3e9c19ac6be06",
     "locked": true,
     "points": 5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "action distribution: [ 29.  35. 936.]\n"
     ]
    }
   ],
   "source": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "np.random.seed(0)\n",
    "\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",
    "action_distribution = np.zeros(3)\n",
    "for i in range(1000):\n",
    "    chosen_action, action_value = agent.select_action(np.array([0,1]))\n",
    "    action_distribution[chosen_action] += 1\n",
    "    \n",
    "print(\"action distribution:\", action_distribution)\n",
    "# notice that the two non-greedy actions are roughly uniformly distributed\n",
    "assert np.all(action_distribution == [29, 35, 936])\n",
    "\n",
    "agent = SarsaAgent()\n",
    "agent.agent_init({\"epsilon\": 0.0})\n",
    "agent.w = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "\n",
    "chosen_action, action_value = agent.select_action([0, 1])\n",
    "assert chosen_action == 2\n",
    "assert action_value == 15\n",
    "\n",
    "# -----------\n",
    "# test update\n",
    "# -----------\n",
    "agent = SarsaAgent()\n",
    "agent.agent_init({\"epsilon\": 0.1})\n",
    "\n",
    "agent.agent_start((0.1, 0.3))\n",
    "agent.agent_step(1, (0.02, 0.1))\n",
    "\n",
    "assert np.all(agent.w[0,0:8] == 0.0625)\n",
    "assert np.all(agent.w[1:] == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "31da193410fe9153637b4e5043c81176",
     "grade": true,
     "grade_id": "cell-5e2a49e089992132",
     "locked": true,
     "points": 25,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUN: 0\n",
      "RUN: 5\n",
      "Run time: 12.592859029769897\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": [
    "# -----------\n",
    "# Tested Cell\n",
    "# -----------\n",
    "# The contents of the cell will be tested by the autograder.\n",
    "# If they do not pass here, they will not pass there.\n",
    "\n",
    "np.random.seed(0)\n",
    "\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",
    "mean = np.mean(all_steps, axis=0)\n",
    "plt.plot(mean)\n",
    "\n",
    "# because we set the random seed, these values should be *exactly* the same\n",
    "assert np.allclose(mean, [1432.5, 837.9, 694.4, 571.4, 515.2, 380.6, 379.4, 369.6, 357.2, 316.5, 291.1, 305.3, 250.1, 264.9, 235.4, 242.1, 244.4, 245., 221.2, 229., 238.3, 211.2, 201.1, 208.3, 185.3, 207.1, 191.6, 204., 214.5, 207.9, 195.9, 206.4, 194.9, 191.1, 195., 186.6, 171., 177.8, 171.1, 174., 177.1, 174.5, 156.9, 174.3, 164.1, 179.3, 167.4, 156.1, 158.4, 154.4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1decba9ad1d71bdd4a835f9ae46378dd",
     "grade": false,
     "grade_id": "cell-8178ac2e12418ca5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": {
     "cell_type": "markdown",
     "checksum": "6fbb20239a03855fc6a21a05fbf1ddf5",
     "grade": false,
     "grade_id": "cell-f395294510618c9b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": 10,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "80a5fffe28f2e72b4745e265bbd276a7",
     "grade": false,
     "grade_id": "cell-f608c2e9a0d94727",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "stepsize: 0.25\n",
      "Run Time: 62.04861903190613\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "stepsize: 0.015625\n",
      "Run Time: 35.63284945487976\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "stepsize: 0.0625\n",
      "Run Time: 35.020058155059814\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6ca66e43d0>"
      ]
     },
     "execution_count": 10,
     "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": [
    "# ---------------\n",
    "# Discussion Cell\n",
    "# ---------------\n",
    "\n",
    "np.random.seed(0)\n",
    "\n",
    "# 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(\"stepsize:\", 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": {
     "cell_type": "markdown",
     "checksum": "bd4932e9dfc12e055b297632bd3e55a5",
     "grade": false,
     "grade_id": "cell-a9d6014459310d14",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": {
     "cell_type": "markdown",
     "checksum": "8bfe024cdf651a451f5be7e3e8df8325",
     "grade": false,
     "grade_id": "cell-b583918603d6925b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Section 3: Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5b7683cc73139dd200ecf0dd1c2b6f4e",
     "grade": false,
     "grade_id": "cell-d15725ba24684800",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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": {
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}