{
 "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": 1,
   "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": 2,
   "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": 3,
   "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": 4,
   "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",
    "        action_values = np.zeros(self.num_actions)\n",
    "        for action in range(self.num_actions):\n",
    "            action_values[action] = np.sum(self.w[action][tiles])\n",
    "        \n",
    "        if np.random.random() < self.epsilon:\n",
    "            chosen_action = np.random.randint(0, 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, action_value = 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, velocity)\n",
    "        current_action, action_value = self.select_action(active_tiles)\n",
    "        \n",
    "        last_action_value = np.sum(self.w[self.last_action][self.previous_tiles])\n",
    "        self.w[self.last_action][self.previous_tiles] += self.alpha * (reward + self.gamma * action_value - last_action_value) * 1\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",
    "        last_action_value = np.sum(self.w[self.last_action][self.previous_tiles])\n",
    "        self.w[self.last_action][self.previous_tiles] += self.alpha * (reward - last_action_value) * 1\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": 5,
   "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": [
      "14460.0\n",
      "Expected value\n",
      "(2, 15)\n",
      "Your value\n",
      "(2, 15.0)\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": 6,
   "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: 10.294790744781494\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": 7,
   "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: 52.46225571632385\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.015625\n",
      "Run Time: 30.930733919143677\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.0625\n",
      "Run Time: 31.441166400909424\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fc7abc049b0>"
      ]
     },
     "execution_count": 7,
     "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
}