ex6_DynaQ_DynaQ+/ex6_DynaQ_DynaQ+.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "# Please install the following python libraries\n",
    "- python3: https://www.python.org/\n",
    "- numpy: https://numpy.org/install/\n",
    "- tqdm: https://github.com/tqdm/tqdm#installation\n",
    "- matplotlib: https://matplotlib.org/stable/users/installing/index.html\n",
    "\n",
    "If you encounter the error: \"IProgress not found. Please update jupyter & ipywidgets\"\n",
    "    \n",
    "Please install the ipywidgets as follows:\n",
    "\n",
    "    with pip, do\n",
    "    - pip install ipywidgets\n",
    "    \n",
    "    with conda, do\n",
    "    - conda install -c conda-forge ipywidgets\n",
    "    \n",
    "Restart your notebook "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tqdm\n",
    "import math\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pre-implemented environments\n",
    "We provide you the implementation of all the environments that you would use to finish this assignment. They are:\n",
    "- **Blocking Maze**: Please read the Example 8.2 (on page 166 in RL2e) for more details\n",
    "- **Shortcut Maze**: Please read the Example 8.3 (on page 167 in RL2e) for more details\n",
    "- **Stochastic Windy GridWorld**: Please read the Example 6.5 (on page 130 in RL2e) for more details\n",
    "\n",
    "For all the environments, in general, they consist of:\n",
    "- A **grid** that represents the domain space. In other words, the state space contains the coordinates (e.g., [x, y]) of all empty cells that are accessible by the agent. \n",
    "- A discrete **action space** that contains 4 actions: up, down, left and right. Specifically, the **step** function in each implementation takes a **string variable** that contains the name of the action.\n",
    "- All the tasks are episodic task. But, please read the description carefully in the book. Because in some task, a new episode will start only when the agent reaches the goal location. In other words, they might not have a timeout."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Blocking Maze\n",
    "In **Blocking Maze**, the agent starts the experiment by interacting with the maze on the left. Then, at time step = 1000, the environment is switched to the maze on the right. For each episode, the agent always starts at the start location (marked as S) and is asked to navigate to the goal location (marked as G). The agent receives reward = 1 when it reaches the goal and receives 0 otherwise. \n",
    "\n",
    "Before you use this implementation, please read the code and make sure you understand it. You are also welcome to implement your own version. If you do that, please replace the following block with your own implementation and add reasonable comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BlockingMaze(object):\n",
    "    \"\"\" Implementation of the Blocking Maze \"\"\"\n",
    "    def __init__(self):\n",
    "        # We define the grid for the maze on the left in Example 8.2\n",
    "        self.left_grid = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [1, 1, 1, 1, 1, 1, 1, 1, 0],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0]])\n",
    "\n",
    "        # We define the grid for the maze on the right in Example 8.2\n",
    "        self.right_grid = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 1, 1, 1, 1, 1, 1, 1, 1],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0]])\n",
    "\n",
    "        # We initialize the grid with using the left maze first\n",
    "        self.grid = self.left_grid.copy()\n",
    "        # Save the size of the maze\n",
    "        self.grid_height, self.grid_width = self.grid.shape\n",
    "\n",
    "        # We define the observation space using all empty cells.\n",
    "        # We consider all cells. Because the environment switch will results in change of the state space\n",
    "        self.observation_space = np.argwhere(np.zeros((self.grid_height, self.grid_width)) == 0.0).tolist()\n",
    "\n",
    "        # We define the action space\n",
    "        self.action_space = {\n",
    "            \"up\": np.array([-1, 0]),\n",
    "            \"down\": np.array([1, 0]),\n",
    "            \"left\": np.array([0, -1]),\n",
    "            \"right\": np.array([0, 1])\n",
    "        }\n",
    "        self.action_names = [\"up\", \"down\", \"left\", \"right\"]\n",
    "\n",
    "        # We define the start state\n",
    "        self.start_location = [5, 3]\n",
    "\n",
    "        # We define the goal state\n",
    "        self.goal_location = [0, 8]\n",
    "\n",
    "        # We find all wall locations in the grid\n",
    "        self.walls = np.argwhere(self.grid == 1.0).tolist()\n",
    "\n",
    "        # We define other useful variables\n",
    "        self.agent_location = None\n",
    "        self.action = None\n",
    "\n",
    "    def reset(self, shift_maze=None):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            shift_maze (string): if None, reset function simply set the agent back to the start location\n",
    "                                 if left, reset function will switch to the maze on the left\n",
    "                                 if right, reset function will switch to the maze on the right\n",
    "        \"\"\"\n",
    "        if shift_maze is not None:\n",
    "            if shift_maze == \"left\":\n",
    "                self.grid = self.left_grid.copy()\n",
    "            elif shift_maze == \"right\":\n",
    "                self.grid = self.right_grid.copy()\n",
    "            else:\n",
    "                raise Exception(\"Invalid shift operation\")\n",
    "\n",
    "            # reset the shape\n",
    "            self.grid_height, self.grid_width = self.grid.shape\n",
    "\n",
    "            # reset the walls\n",
    "            self.walls = np.argwhere(self.grid == 1.0).tolist()\n",
    "\n",
    "        # We reset the agent location to the start state\n",
    "        self.agent_location = self.start_location\n",
    "\n",
    "        # We set the information\n",
    "        info = {}\n",
    "        return self.agent_location, info\n",
    "\n",
    "    def step(self, action):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            action (string): name of the action (e.g., \"up\"/\"down\"/\"left\"/\"right\")\n",
    "        \"\"\"\n",
    "        # Convert the agent's location to array\n",
    "        loc_arr = np.array(self.agent_location)\n",
    "\n",
    "        # Convert the abstract action to movement array\n",
    "        act_arr = self.action_space[action]\n",
    "\n",
    "        # Compute the next location\n",
    "        next_agent_location = np.clip(loc_arr + act_arr,\n",
    "                                      a_min=np.array([0, 0]),\n",
    "                                      a_max=np.array([self.grid_height - 1, self.grid_width - 1])).tolist()\n",
    "\n",
    "        # Check if it crashes into a wall\n",
    "        if next_agent_location in self.walls:\n",
    "            # If True, the agent keeps in the original state\n",
    "            next_agent_location = self.agent_location\n",
    "\n",
    "        # Compute the reward\n",
    "        reward = 1 if next_agent_location == self.goal_location else 0\n",
    "\n",
    "        # Check the termination\n",
    "        terminated = True if reward == 1 else False\n",
    "\n",
    "        # Update the action location\n",
    "        self.agent_location = next_agent_location\n",
    "        self.action = action\n",
    "\n",
    "        return next_agent_location, reward, terminated#, False, {}\n",
    "\n",
    "    def render(self):\n",
    "        # plot the agent and the goal\n",
    "        # agent = 1\n",
    "        # goal = 2\n",
    "        plot_arr = self.grid.copy()\n",
    "        plot_arr[self.agent_location[0], self.agent_location[1]] = 2\n",
    "        plot_arr[self.goal_location[0], self.goal_location[1]] = 3\n",
    "        plt.clf()\n",
    "        plt.title(f\"state={self.agent_location}, act={self.action}\")\n",
    "        plt.imshow(plot_arr)\n",
    "        plt.show(block=False)\n",
    "        plt.pause(0.01)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shortcut Maze\n",
    "In **Shortcut Maze**, the agent starts the experiment by interacting with the maze on the left. Then, at time step = 3000, the environment is switched to the maze on the right. For each episode, the agent always starts at the start location (marked as S) and is asked to navigate to the goal location (marked as G). The agent receives reward = 1 when it reaches the goal and receives 0 otherwise. \n",
    "\n",
    "Before you use this implementation, please read the code and make sure you understand it. You are also welcome to implement your own version. If you do that, please replace the following block with your own implementation and add reasonable comments\n",
    "\n",
    "Since **Shortcut Maze** is different with **Blocking Maze** in terms of the maze grids. We will inherit **Blocking Maze** and only change the followings:\n",
    "1. Reset the grid of the left maze \n",
    "2. Reset the grid of the right maze\n",
    "3. Reset the initial maze to be the left one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShortcutMaze(BlockingMaze):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        # We define the grid for the maze on the left in Example 8.3\n",
    "        self.left_grid = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [0, 1, 1, 1, 1, 1, 1, 1, 1],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                   [0, 0, 0, 0, 0, 0, 0, 0, 0]])\n",
    "\n",
    "        # We define the grid for the maze on the right in Example 8.3\n",
    "        self.right_grid = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 1, 1, 1, 1, 1, 1, 1, 0],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                                    [0, 0, 0, 0, 0, 0, 0, 0, 0]])\n",
    "        \n",
    "        # We reset the domain to be the left maze first\n",
    "        self.reset(shift_maze=\"left\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The plot function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_curves(arr_list, legend_list, color_list, ylabel, fig_title):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        arr_list (list): list of results arrays to plot\n",
    "        legend_list (list): list of legends corresponding to each result array\n",
    "        color_list (list): list of color corresponding to each result array\n",
    "        ylabel (string): label of the Y axis\n",
    "\n",
    "        Note that, make sure the elements in the arr_list, legend_list and color_list are associated with each other correctly.\n",
    "        Do not forget to change the ylabel for different plots.\n",
    "    \"\"\"\n",
    "    # set the figure type\n",
    "    fig, ax = plt.subplots(figsize=(12, 8))\n",
    "\n",
    "    # PLEASE NOTE: Change the labels for different plots\n",
    "    ax.set_ylabel(ylabel)\n",
    "    ax.set_xlabel(\"Time Steps\")\n",
    "\n",
    "    # ploth results\n",
    "    h_list = []\n",
    "    for arr, legend, color in zip(arr_list, legend_list, color_list):\n",
    "        # compute the standard error\n",
    "        arr_err = arr.std(axis=0) / np.sqrt(arr.shape[0])\n",
    "        # plot the mean\n",
    "        h, = ax.plot(range(arr.shape[1]), arr.mean(axis=0), color=color, label=legend)\n",
    "        # plot the confidence band\n",
    "        arr_err *= 1.96\n",
    "        ax.fill_between(range(arr.shape[1]), arr.mean(axis=0) - arr_err, arr.mean(axis=0) + arr_err, alpha=0.3,\n",
    "                        color=color)\n",
    "        # save the plot handle\n",
    "        h_list.append(h)\n",
    "\n",
    "    # plot legends\n",
    "    ax.set_title(f\"{fig_title}\")\n",
    "    ax.legend(handles=h_list)\n",
    "\n",
    "    # save the figure\n",
    "    plt.savefig(f\"{fig_title}.png\", dpi=200)\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Q3: (a) - Implement Dyna-Q and Dyna-Q+ to reproduce Figure 8.4\n",
    "\n",
    "- Use the **BlockingMaze** environment;\n",
    "- Reproduce the Figure 8.4 on page 167\n",
    "    - X axis: the learning time step. In other words, it is the number of time steps that agent really interacts with the environment;\n",
    "    - Y axis: the cumulative reward, a sum of all rewards received by the agent by a particular time step t. \n",
    "- Hyperparameters:\n",
    "    - Dyna-Q:\n",
    "        - learning time steps: 3000\n",
    "        - planning steps number: 250\n",
    "        - alpha: 0.1\n",
    "        - gamma: 0.95\n",
    "        - epsilon: 0.1\n",
    "        - time to switch the maze: 1000\n",
    "    - Dyna-Q+:\n",
    "        - learning time steps: 3000\n",
    "        - planning steps number: 250\n",
    "        - alpha: 0.1\n",
    "        - gamma: 0.95\n",
    "        - epsilon: 0.1\n",
    "        - kappa: 5e-4\n",
    "        - time to switch the maze: 1000\n",
    "        \n",
    "Note that, to implement the Dyna-Q+, please read the section 8.3 and the footnote on page 168 carefully. For Dyna-Q+, we ask you to implement **two variants**. For the first variant, it does **not** use the strategy in the footnote. For the second, it use the strategy proposed in the footnote. Finally, besides the two lines in Figure 8.4, please add a third line for Dyna-Q+ without using the footnote strategy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" We will implement the Dyna-Q as a class that contains the following attributes:\n",
    "        - self.env: an environment object\n",
    "        - self.q_table: a 2-D array with shape (num_state, num_action) that stores the Q values \n",
    "        - self.model: a nested dictionary that stores the past experiences\n",
    "    Note that:\n",
    "        There exists one attribute \"self.maze_switch_time\". It indicates the time to switch from the left maze\n",
    "        to the right maze during the learning process.\n",
    "        \n",
    "    Please complete this class by adding your implementation in the following functions:\n",
    "        - self.update_model\n",
    "        - self.update_q_table\n",
    "        - self.run_planning_step\n",
    "        - self.run\n",
    "              \n",
    "\"\"\"\n",
    "class TabularDynaQAgent(object):\n",
    "    def __init__(self, env, info):\n",
    "        # Store the environment\n",
    "        self.env = env\n",
    "\n",
    "        # Store the maximal learning steps\n",
    "        self.k = info['learning_step']\n",
    "\n",
    "        # Store the planning steps\n",
    "        self.n = info['planning_step']\n",
    "\n",
    "        # Store the Q-learning step size alpha\n",
    "        self.alpha = info['alpha']\n",
    "\n",
    "        # Store the discount factor\n",
    "        self.gamma = info['gamma']\n",
    "\n",
    "        # Initialize the epsilon for epsilon-greedy policy\n",
    "        self.epsilon = info['epsilon']\n",
    "\n",
    "        # Initialize the switch time\n",
    "        self.maze_switch_time = info['switch_time_step']\n",
    "        \n",
    "        # Compute total number of the state\n",
    "        self.state_num = len(self.env.observation_space)\n",
    "\n",
    "        # Compute the number of the actions\n",
    "        self.action_num = len(self.env.action_names)\n",
    "\n",
    "        # Initialize the Q(s, a): a table stores (s, a)\n",
    "        self.q_table = np.zeros((self.state_num, self.action_num))\n",
    "\n",
    "        # Initialize the model\n",
    "        # We represent the model as a dictionary of dictionary.\n",
    "        # Specifically, the keys for the outside dictionary is a state tuple (the key should be immutable).\n",
    "        # Given one state tuple key, its value is also a dictionary whose keys are actions names and values are a tuple consisting of (reward, next_state).\n",
    "        # Given an empty model and a transition (s, a, r, s'), the self.model can be updated as\n",
    "        # {s: {a: (r, s')}}.\n",
    "        # E.g. {(0, 0): {'right': (0, [0, 2]), 'left': (0, [0, 0]), ...}, ...}\n",
    "        # We usually call (s, a, r, s') a transition tuple\n",
    "        self.model = {}\n",
    "\n",
    "    def _get_state_idx(self, state):\n",
    "        \"\"\"\n",
    "        Function returns the index of the state in the q table (i.e., row index)\n",
    "        Args:\n",
    "             state (tuple): a tuple contains the state\n",
    "        \"\"\"\n",
    "        state = list(state)\n",
    "        return self.env.observation_space.index(state)\n",
    "\n",
    "    def _get_action_idx(self, action):\n",
    "        \"\"\"\n",
    "        Function returns the index of the action in the q table (i.e., column index)\n",
    "        Args:\n",
    "            action (string): action name\n",
    "        \"\"\"\n",
    "        return self.env.action_names.index(action)\n",
    "\n",
    "    def epsilon_greedy_policy(self, state):\n",
    "        \"\"\"\n",
    "        Function implements the epsilon-greedy policy\n",
    "        Args:\n",
    "            state (tuple): a tuple contains the state\n",
    "        \"\"\"\n",
    "        if random.random() < self.epsilon:  # with p = epsilon, we randomly sample an action\n",
    "            return random.sample(self.env.action_names, 1)[0]\n",
    "        else:  # With p = 1 - epsilon, derive a greedy policy from the Q table\n",
    "            state_idx = self._get_state_idx(state)\n",
    "            q_values = self.q_table[state_idx]\n",
    "            max_action_list = np.where(q_values == q_values.max())[0].tolist()\n",
    "            max_action_idx = random.sample(max_action_list, 1)[0]\n",
    "            return self.env.action_names[max_action_idx]  # break ties\n",
    "\n",
    "                                            #########################\n",
    "                                            ##### MY WORK START #####\n",
    "                                            #########################\n",
    "    \n",
    "    def update_model(self, s, a, r, next_s):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            s (list): contains the location of the agent\n",
    "            a (string): name of the action\n",
    "            r (int): reward\n",
    "            next_s (list): contains the location of the agent after taking the action\n",
    "        \"\"\"        \n",
    "        # check whether tuple s is a key in the dictionary\n",
    "        s_tup = tuple(s)\n",
    "        if s_tup in self.model:\n",
    "            stInModel = True\n",
    "            if a in self.model[s_tup]:\n",
    "                # state-action pair already in model\n",
    "                aInModel = True\n",
    "            else:\n",
    "                # state in model, action not\n",
    "                aInModel = False\n",
    "        else:\n",
    "            # state not in model, so action also not in model\n",
    "            stInModel = False\n",
    "            aInModel = False\n",
    "        \n",
    "        \n",
    "        # update the model by adding the transition as \"tuple s\": {a: (r, next_s)}\n",
    "        if stInModel is True and aInModel is False:\n",
    "            # State already in model, but action is not, update self.model[s_tup] with action\n",
    "            self.model[s_tup].update({a: (r, next_s)})\n",
    "        elif stInModel and aInModel:\n",
    "            # Both already exist, set equal to new value\n",
    "            self.model[s_tup][a] = (r, next_s)\n",
    "        else:\n",
    "            # Both false, update self.model with state and action\n",
    "            self.model.update({s_tup: {a: (r, next_s)}})\n",
    "\n",
    "\n",
    "    def update_q_table(self, s, a, r, next_s):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            s (list): contains the location of the agent\n",
    "            a (string): name of the action\n",
    "            r (int): reward\n",
    "            next_s (list): contains the location of the agent after taking the action\n",
    "        \"\"\"\n",
    "        # obtain the table index for s and next_s\n",
    "        s_index = self._get_state_idx(s)\n",
    "        sp_index = self._get_state_idx(next_s)\n",
    "        \n",
    "        # obtain the table index for a\n",
    "        a_index = self._get_action_idx(a)\n",
    "        \n",
    "        # update the Q table\n",
    "        # Q(S, A) = Q(S, A) + alpha*(R + gamma*max_a{Q(S', a)} - Q(S, A))\n",
    "        self.q_table[s_index, a_index] += self.alpha*(r + self.gamma*np.amax(self.q_table[sp_index, :]) - self.q_table[s_index, a_index])\n",
    "\n",
    "    def run_planning_step(self):\n",
    "        for _ in range(self.n):\n",
    "            # randomly sample a previously observe state, you can sample it from the self.model.keys()\n",
    "            state = random.choice(list(self.model.keys()))\n",
    "            \n",
    "            # randomly sample an action previously taken in state, you can sample it from the self.model[state].keys()\n",
    "            action = random.choice(list(self.model[state].keys()))\n",
    "            \n",
    "            # render the reward and the next state given the state and action use the model\n",
    "            reward, next_state = self.model[state][action]\n",
    "\n",
    "            # update the Q table using Q-learning\n",
    "            self.update_q_table(state, action, reward, next_state)\n",
    "\n",
    "    def run(self):\n",
    "        # record the reward\n",
    "        cumulative_reward = 0\n",
    "\n",
    "        # save the cumulative reward w.r.t. each time step\n",
    "        cumulative_rewards_wrt_time_steps = np.zeros(self.k)\n",
    "\n",
    "        # Dyna-Q starts\n",
    "        state, _ = self.env.reset()\n",
    "        for t in range(self.k):\n",
    "            # derive an action with epsilon-greedy policy\n",
    "            action = self.epsilon_greedy_policy(state)\n",
    "            \n",
    "            # take the action and observe reward and next state\n",
    "            next_state, reward, done = self.env.step(action)    #, f, empty_dict\n",
    "            \n",
    "            # update the Q table using Q-learning\n",
    "            self.update_q_table(state, action, reward, next_state)\n",
    "            \n",
    "            # update model\n",
    "            self.update_model(state, action, reward, next_state)\n",
    "            \n",
    "            # planning starts\n",
    "            self.run_planning_step()\n",
    "            \n",
    "            # uncomment print info for debug\n",
    "            # print(f\"t = {t}, s = {state}, a = {action}, r = {reward}, next_s = {next_state}, done = {done}\")\n",
    "            \n",
    "            # store the cumulative rewards\n",
    "            cumulative_reward += reward\n",
    "            cumulative_rewards_wrt_time_steps[t] = cumulative_reward\n",
    "\n",
    "            # reset the environment\n",
    "            if t == self.maze_switch_time:\n",
    "                state, _ = self.env.reset(shift_maze=\"right\")\n",
    "            else:\n",
    "                if done:\n",
    "                    state, _ = self.env.reset()\n",
    "                else:\n",
    "                    state = next_state\n",
    "\n",
    "        return cumulative_rewards_wrt_time_steps\n",
    "    \n",
    "                                            #######################\n",
    "                                            ##### MY WORK END #####\n",
    "                                            #######################\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Here is the implementation of Dyna-Q+ without the footnote strategy. \n",
    "    We will inherit from the Dyna-Q above.\n",
    "    \n",
    "    Recall, to compute the \"bonus reward\" = r + kappa * sqrt(elapsed time) for each planning step, \n",
    "    We have to store (s, a, r, s', t) in Dyna-Q+ instead of (s, a, r, s') in Dyna-Q in the model.\n",
    "    Therefore, since we have to store an extra t, we only have to change three methods:\n",
    "        - self.run: Because we use it to collect (s, a, r, s', t)\n",
    "        - self.update_model: Because we use it to add transitions to the model.\n",
    "        - self.run_planning_step: Because we use it to compute the \"bonus reward\" = r + kappa * sqrt(time elasped)\n",
    "\"\"\"\n",
    "class TabularDynaQPlusAgent(TabularDynaQAgent):\n",
    "    def __init__(self, env, info):\n",
    "        super().__init__(env, info)\n",
    "        \n",
    "        # add one parameter \"kappa\" to compute the bonus reward defined as: r + kappa * sqrt(elapsed time steps)\n",
    "        self.kappa = info['kappa']\n",
    "\n",
    "                                            #########################\n",
    "                                            ##### MY WORK START #####\n",
    "                                            #########################\n",
    "        \n",
    "    def update_model(self, s, a, r, next_s, last_t):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            s (list): contains the location of the agent\n",
    "            a (string): name of the action\n",
    "            r (int): reward\n",
    "            next_s (list): contains the location of the agent after taking the action\n",
    "            last_t (int): the real time step that the transition is encountered\n",
    "        \"\"\"\n",
    "        # similar to the previous update. This time add last_t as one component\n",
    "        # check whether tuple s is a key in the dictionary\n",
    "        \n",
    "        # Same explanation as above\n",
    "        s_tup = tuple(s)\n",
    "        if s_tup in self.model:\n",
    "            stInModel = True\n",
    "            if a in self.model[s_tup]:\n",
    "                aInModel = True\n",
    "            else:\n",
    "                aInModel = False\n",
    "        else:\n",
    "            stInModel = False\n",
    "            aInModel = False\n",
    "        \n",
    "\n",
    "        # update the model by adding the transition as \"tuple s\": {a: (r, next_s, last_t)}\n",
    "        if stInModel is True and aInModel is False:\n",
    "            # State already in model, but action is not, update self.model[s_tup] with action\n",
    "            self.model[s_tup].update({a: (r, next_s, last_t)})\n",
    "        elif stInModel and aInModel:\n",
    "            # Both already exist, set equal to new value\n",
    "            self.model[s_tup][a] = (r, next_s, last_t)\n",
    "        else:\n",
    "            # Both false, update self.model with state and action\n",
    "            self.model.update({s_tup: {a: (r, next_s, last_t)}})\n",
    "    \n",
    "        \n",
    "    def run_planning_step(self, current_t):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            current_t (int): current time step in the learning process. We use it as well as the time recorded in\n",
    "            each transition to compute the elasped time. \n",
    "        \"\"\"\n",
    "        for _ in range(self.n):\n",
    "            # randomly sample a previously observe state\n",
    "            state = random.choice(list(self.model))\n",
    "            \n",
    "            # randomly sample an action previously taken in state\n",
    "            action = random.choice(list(self.model[state]))\n",
    "            \n",
    "            # render the reward and the next state given the state and action use the model\n",
    "            reward, next_state, last_t = self.model[state][action]\n",
    "            \n",
    "            # compute the \"bonus\" reward = r + kappa * sqrt(time elasped)\n",
    "            t_elapsed = current_t - last_t\n",
    "            reward += self.kappa*math.sqrt(t_elapsed)\n",
    "            \n",
    "            # update the Q table using Q-learning\n",
    "            super().update_q_table(state, action, reward, next_state)\n",
    "            \n",
    "    def run(self):\n",
    "        # record the reward\n",
    "        cumulative_reward = 0\n",
    "\n",
    "        # save the cumulative reward w.r.t. each time step\n",
    "        cumulative_rewards_wrt_time_steps = np.zeros(self.k)\n",
    "\n",
    "        # Dyna-Q starts\n",
    "        state, _ = self.env.reset()\n",
    "        for t in range(self.k):\n",
    "            # derive an action with epsilon-greedy policy\n",
    "            action = super().epsilon_greedy_policy(state)\n",
    "            \n",
    "            # take the action and observe reward and next state\n",
    "            next_state, reward, done = self.env.step(action)\n",
    "\n",
    "            # update the Q table using Q-learning\n",
    "            super().update_q_table(state, action, reward, next_state)\n",
    "            \n",
    "            # update model\n",
    "            self.update_model(state, action, reward, next_state, t)\n",
    "            \n",
    "            # planning step\n",
    "            self.run_planning_step(t)\n",
    "\n",
    "            # uncomment print info for debug\n",
    "            # print(f\"t = {t}, s = {state}, a = {action}, r = {reward}, next_s = {next_state}, done = {done}\")\n",
    "\n",
    "            # store the cumulative rewards\n",
    "            cumulative_reward += reward\n",
    "            cumulative_rewards_wrt_time_steps[t] = cumulative_reward\n",
    "\n",
    "            # reset the environment\n",
    "            if t == self.maze_switch_time:\n",
    "                state, _ = self.env.reset(shift_maze=\"right\")\n",
    "            else:\n",
    "                if done:\n",
    "                    state, _ = self.env.reset()\n",
    "                else:\n",
    "                    state = next_state\n",
    "\n",
    "        return cumulative_rewards_wrt_time_steps\n",
    "    \n",
    "    \n",
    "                                            #######################\n",
    "                                            ##### MY WORK END #####\n",
    "                                            #######################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Here is the implementation of Dyna-Q+ with the footnote strategy. \n",
    "    We will inherit from the Dyna-Q+ without footnote above.\n",
    "    \n",
    "    Recall, the only difference between the two variants of Dyna-Q+ is whether we consider untried actions \n",
    "    from a state during the planning stage. Therefore, based on the footnote, we only have to change one method:\n",
    "        - self.run_planning_step:\n",
    "            - We will compute the \"bonus reward\" = r + kappa * sqrt(time elasped)\n",
    "            - We will try untried actions from state (See footnote on p.168 for more details)\n",
    "\"\"\"\n",
    "class TabularDynaQPlusAgentFontNote(TabularDynaQPlusAgent):\n",
    "    def __init__(self, env, info):\n",
    "        super().__init__(env, info)\n",
    "        \n",
    "                                            #########################\n",
    "                                            ##### MY WORK START #####\n",
    "                                            #########################\n",
    "        \n",
    "    def run_planning_step(self, current_t):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            current_t (int): current time step in the learning process. We use it as well as the time recorded in\n",
    "            each transition to compute the elasped time. \n",
    "        \"\"\"\n",
    "        for _ in range(self.n):\n",
    "            # randomly sample a previously observe state\n",
    "            state = random.choice(list(self.model.keys()))\n",
    "            \n",
    "            # randomly sample an action (all actions in the action space\n",
    "            # are valid from one state based on the footnote)\n",
    "            action = random.choice(self.env.action_names)\n",
    "            \n",
    "            # check if the action is tried before\n",
    "            if action in self.model[state]:\n",
    "                # If True, render the reward and the next state given the state and action use the model\n",
    "                reward, next_state, last_t = self.model[state][action]\n",
    "            else:\n",
    "                # If False, set values for the reward, next_state, and t suggested by the footnote\n",
    "                reward, next_state, last_t = (0, state, 0)\n",
    "                \n",
    "            # compute the \"bonus\" reward\n",
    "            t_elapsed = current_t - last_t\n",
    "            reward += self.kappa*math.sqrt(t_elapsed)\n",
    "            \n",
    "            # update the Q table using Q-learning\n",
    "            super().update_q_table(state, action, reward, next_state)\n",
    "            \n",
    "            \n",
    "                                            #######################\n",
    "                                            ##### MY WORK END #####\n",
    "                                            #######################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████| 10/10 [01:15<00:00,  7.58s/it]\n",
      "100%|███████████████████████████████████████████████████████████████| 10/10 [01:16<00:00,  7.63s/it]\n",
      "100%|███████████████████████████████████████████████████████████████| 10/10 [01:13<00:00,  7.39s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\" Here is the code to reproduce the Figure 8.4. It takes on average around 1 min (Macbook Pro M1)\n",
    "    to run one method using the following parameters for experiments:\n",
    "        - learning step = 3000\n",
    "        - planning step = 250\n",
    "        - alpha (Q-learning update step) = 0.1\n",
    "        - gamma (discount factor) = 0.95\n",
    "        - epsilon (epsilon-greedy) = 0.1\n",
    "        - kappa (\"bonus reward\") = 5e-4\n",
    "        \n",
    "    We run 10 trials and plot the results. \n",
    "\"\"\"\n",
    "if __name__ == \"__main__\":\n",
    "    # set the random seed\n",
    "    np.random.seed(1234)\n",
    "    random.seed(1234)\n",
    "\n",
    "    # set hyper-parameters\n",
    "    params = {\n",
    "        \"switch_time_step\": 1000,\n",
    "        \"learning_step\": 3000,\n",
    "        \"planning_step\": 250,\n",
    "        \"alpha\": 0.1,\n",
    "        \"gamma\": 0.95,\n",
    "        \"epsilon\": 0.1,\n",
    "        \"kappa\": 5e-4\n",
    "    }\n",
    "\n",
    "    \"\"\" Set running trials for experiments \n",
    "    \"\"\"\n",
    "    run_trial_num = 10\n",
    "\n",
    "    \"\"\" Run Dyna-Q\n",
    "    \"\"\"\n",
    "    results_dyna_q = []\n",
    "    for r in tqdm.trange(run_trial_num):\n",
    "        # create the environment\n",
    "        my_env = BlockingMaze()\n",
    "\n",
    "        # create the agent for Dyna-Q\n",
    "        dyna_q_agent = TabularDynaQAgent(my_env, params)\n",
    "        result = dyna_q_agent.run()\n",
    "\n",
    "        results_dyna_q.append(result)\n",
    "\n",
    "    \"\"\" Run Dyna-Q+ without the footnote\n",
    "    \"\"\"\n",
    "    results_dyna_q_plus = []\n",
    "    for r in tqdm.trange(run_trial_num):\n",
    "        # create the environment\n",
    "        my_env = BlockingMaze()\n",
    "\n",
    "        # create the agent for Dyna-Q\n",
    "        dyna_q_plus_agent = TabularDynaQPlusAgent(my_env, params)\n",
    "        result = dyna_q_plus_agent.run()\n",
    "\n",
    "        results_dyna_q_plus.append(result)\n",
    "\n",
    "    \"\"\" Run Dyna-Q+ with the footnote\n",
    "    \"\"\"\n",
    "    results_dyna_q_plus_fn = []\n",
    "    for r in tqdm.trange(run_trial_num):\n",
    "        # create the environment\n",
    "        my_env = BlockingMaze()\n",
    "\n",
    "        # create the agent for Dyna-Q\n",
    "        dyna_q_plus_agent_fn = TabularDynaQPlusAgentFontNote(my_env, params)\n",
    "        result = dyna_q_plus_agent_fn.run()\n",
    "\n",
    "        results_dyna_q_plus_fn.append(result)\n",
    "\n",
    "    \"\"\" Plot the results\n",
    "    \"\"\"\n",
    "    plot_curves([np.array(results_dyna_q), np.array(results_dyna_q_plus), np.array(results_dyna_q_plus_fn)],\n",
    "                [\"Dyan-Q\", \"Dyna-Q+ no footnote\", \"Dyna-Q+ with footnote\"],\n",
    "                [\"b\", \"g\", \"r\"],\n",
    "                \"Cumulative reward\", \"Reproduced Figure 8.4\")    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Q3: (b) - Implement Dyna-Q and Dyna-Q+ to reproduce Figure 8.5\n",
    "\n",
    "- Use the **ShortcutMaze** environment;\n",
    "- Reproduce the Figure 8.5 on page 167\n",
    "    - X axis: the learning time step. In other words, it is the number of time steps that agent really interacts with the environment;\n",
    "    - Y axis: the cumulative reward, a sum of all rewards received by the agent till a particular time step t. \n",
    "- Hyperparameters:\n",
    "    - Dyna-Q:\n",
    "        - learning time steps: 6000\n",
    "        - planning steps number: 250\n",
    "        - alpha: 0.1\n",
    "        - gamma: 0.95\n",
    "        - epsilon: 0.1\n",
    "        - time to switch the maze: 3000\n",
    "    - Dyna-Q+:\n",
    "        - learning time steps: 6000\n",
    "        - planning steps number: 250\n",
    "        - alpha: 0.1\n",
    "        - gamma: 0.95\n",
    "        - epsilon: 0.1\n",
    "        - kappa: 5e-4\n",
    "        - time to switch the maze: 3000\n",
    "        \n",
    "Note that, to implement the Dyna-Q+, please read the section 8.3 and the footnote on page 168 carefully. For Dyna-Q+, we ask you to implement **two variants**. For the first variant, it does **not** use the strategy in the footnote. For the second, it use the strategy proposed in the footnote. Finally, besides the two lines in Figure 8.5, please add a third line for Dyna-Q+ without using the footnote strategy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████| 10/10 [02:22<00:00, 14.24s/it]\n",
      "100%|███████████████████████████████████████████████████████████████| 10/10 [02:31<00:00, 15.20s/it]\n",
      "100%|███████████████████████████████████████████████████████████████| 10/10 [02:29<00:00, 14.94s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\" Great! You have successfully implement Dyna-Q and Dyna-Q+.\n",
    "    To reproduce the Figure 8.5, just change the environment to be ShortcutMaze. \n",
    "    \n",
    "    It takes on average 2 mins on a Macbook Pro with M1. \n",
    "\"\"\"\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # set the random seed\n",
    "    np.random.seed(1234)\n",
    "    random.seed(1234)\n",
    "\n",
    "    # set hyper-parameters\n",
    "    params = {\n",
    "        \"switch_time_step\": 3000,\n",
    "        \"learning_step\": 6000,\n",
    "        \"planning_step\": 250,\n",
    "        \"alpha\": 0.1,\n",
    "        \"gamma\": 0.95,\n",
    "        \"epsilon\": 0.1,\n",
    "        \"kappa\": 5e-4\n",
    "    }\n",
    "\n",
    "    \"\"\" Set running trials for experiments \n",
    "    \"\"\"\n",
    "    run_trial_num = 10\n",
    "\n",
    "    \"\"\" Run Dyna-Q\n",
    "    \"\"\"\n",
    "    results_dyna_q = []\n",
    "    for r in tqdm.trange(run_trial_num):\n",
    "        # create the environment\n",
    "        my_env = ShortcutMaze()\n",
    "\n",
    "        # create the agent for Dyna-Q\n",
    "        dyna_q_agent = TabularDynaQAgent(my_env, params)\n",
    "        result = dyna_q_agent.run()\n",
    "\n",
    "        results_dyna_q.append(result)\n",
    "\n",
    "    \"\"\" Run Dyna-Q+ without the footnote\n",
    "    \"\"\"\n",
    "    results_dyna_q_plus = []\n",
    "    for r in tqdm.trange(run_trial_num):\n",
    "        # create the environment\n",
    "        my_env = ShortcutMaze()\n",
    "\n",
    "        # create the agent for Dyna-Q\n",
    "        dyna_q_plus_agent = TabularDynaQPlusAgent(my_env, params)\n",
    "        result = dyna_q_plus_agent.run()\n",
    "\n",
    "        results_dyna_q_plus.append(result)\n",
    "\n",
    "    \"\"\" Run Dyna-Q+ with the footnote\n",
    "    \"\"\"\n",
    "    results_dyna_q_plus_fn = []\n",
    "    for r in tqdm.trange(run_trial_num):\n",
    "        # create the environment\n",
    "        my_env = ShortcutMaze()\n",
    "\n",
    "        # create the agent for Dyna-Q\n",
    "        dyna_q_plus_agent_fn = TabularDynaQPlusAgentFontNote(my_env, params)\n",
    "        result = dyna_q_plus_agent_fn.run()\n",
    "\n",
    "        results_dyna_q_plus_fn.append(result)\n",
    "\n",
    "    plot_curves([np.array(results_dyna_q), np.array(results_dyna_q_plus), np.array(results_dyna_q_plus_fn)],\n",
    "                [\"Dyan-Q\", \"Dyna-Q+ no footnote\", \"Dyna-Q+ with footnote\"],\n",
    "                [\"b\", \"g\", \"r\"],\n",
    "                \"Cumulative reward\", \"Reproduced Figure 8.4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Q4: Modify Dyna-Q to solve the Stochastic Windy GridWorld\n",
    "\n",
    "Please implement your modification to the original Dyan-Q algorithm and make it suitable to resolve a stochastic environment. In this case, we use the **stochastic Windy GridWorld** to test your implemtation.\n",
    "\n",
    "The environment implementation is as follows. You can use it directly or implement your own one. However, if you implement your own version, please make sure it is **correct** and **bug-free** and **well commented**. We would not be able to give credits if the environment implementation does not work properly or can not be understood. \n",
    "\n",
    "You can adopt your implementation of Dyna-Q above and make the changes. To show your results, you are asked to provide the followings:\n",
    "\n",
    "1. **Plot a figure** similar to Figure 8.2 in RL2e. Specifically, the x axis is the number of finished episodes; the y axis is the number of the time steps per episode. Note that, you do **not** need to plot curves for different planning steps (i.e., n). Just tune the n that works the best for you and plot the curve for that particular n (i.e., you might find n = 100 works the best in your case). \n",
    "2. **Print out the optimal path** that the algorithm finds by the end of the learning. In particular, you should write a code to do the followings:\n",
    "    - Reset the agent back to the start location;\n",
    "    - Write a for loop to let the agent interact with the environment automatically;\n",
    "    - At each time step, derive a greedy action using the Q table by the end of the learning;\n",
    "    - Observe the next state and reward by taking the action in the environment;\n",
    "    - Print out the followings for each time step:\n",
    "        - Time step stamp\n",
    "        - State (agent's previous location)\n",
    "        - Action (action just taken by the agent)\n",
    "        - Reward (reward for taking that action from previous location)\n",
    "        - Next state (location that agent results in after taking the action)\n",
    "        - Done (termination signal to show whether the episode is terminated)\n",
    "    \n",
    " For example, at time step 0, your code should print the followings:\n",
    " \n",
    "     \"time step = 0, state = [3, 0], action = \"up\", reward = 0, next_state = [2, 0], done = False\"\n",
    " \n",
    " A good policy can guide the agent from the start location to the goal location successfully.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StochasticWindyGridWorld(object):\n",
    "    def __init__(self):\n",
    "        # We define the grid for the DynaMaze domain\n",
    "        self.grid = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
    "                              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])\n",
    "        self.grid_height, self.grid_width = self.grid.shape\n",
    "\n",
    "        # We define the observation space consisting of all empty cells\n",
    "        self.observation_space = np.argwhere(self.grid == 0.0).tolist()\n",
    "\n",
    "        # We define the action space\n",
    "        self.action_space = {\n",
    "            \"up\": np.array([-1, 0]),\n",
    "            \"down\": np.array([1, 0]),\n",
    "            \"left\": np.array([0, -1]),\n",
    "            \"right\": np.array([0, 1])\n",
    "        }\n",
    "        # We define the action names\n",
    "        self.action_names = ['up', 'down', 'left', 'right']\n",
    "\n",
    "        # We define the start state\n",
    "        self.start_location = [3, 0]\n",
    "\n",
    "        # We define the goal state\n",
    "        self.goal_location = [3, 7]\n",
    "\n",
    "        # Define the wind list\n",
    "        self.wind_space = (0, 0, 0, 1, 1, 1, 2, 2, 1, 0)\n",
    "\n",
    "        # We define other useful variables\n",
    "        self.agent_location = None\n",
    "        self.action = None\n",
    "\n",
    "    def reset(self):\n",
    "        # We reset the agent location to the start state\n",
    "        self.agent_location = self.start_location\n",
    "\n",
    "        # We set the information\n",
    "        info = {}\n",
    "        return self.agent_location, info\n",
    "\n",
    "    def step(self, action):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            action (string): name of the action (e.g., \"up\"/\"down\"/\"left\"/\"right\")\n",
    "        \"\"\"\n",
    "        # Convert the agent's location to array\n",
    "        loc_arr = np.array(self.agent_location)\n",
    "\n",
    "        # Convert the action name to movement array\n",
    "        act_arr = self.action_space[action]\n",
    "\n",
    "        # Make the wind stochastic\n",
    "        mean_wind = self.wind_space[self.agent_location[1]]\n",
    "        if mean_wind:  # if the wind exists\n",
    "            wind = np.random.choice([mean_wind - 1,\n",
    "                                     mean_wind,\n",
    "                                     mean_wind + 1],\n",
    "                                    p=[1.0/3.0, 1.0/3.0, 1.0/3.0])\n",
    "            \n",
    "            \n",
    "            \n",
    "            ####################\n",
    "            ##### MY EDITS #####\n",
    "            ####################\n",
    "            \n",
    "            # Output the random \"wind_type\" that was selected above in the np.random.choice()\n",
    "            if wind == mean_wind-1:\n",
    "                wind_type = \"sub\"\n",
    "            elif wind == mean_wind:\n",
    "                wind_type = \"zero\"\n",
    "            else:\n",
    "                wind_type = \"add\"\n",
    "        else:\n",
    "            wind = 0\n",
    "            wind_type = \"none\"\n",
    "            \n",
    "            ####################\n",
    "            ##### MY EDITS #####\n",
    "            ####################\n",
    "            \n",
    "            \n",
    "            \n",
    "        # Compute the wind array\n",
    "        wind_arr = -1 * np.array([wind, 0], dtype=int)\n",
    "\n",
    "        # compute the next state\n",
    "        next_agent_location = np.clip(loc_arr + act_arr + wind_arr,\n",
    "                                      a_min=np.array([0, 0]),\n",
    "                                      a_max=np.array([self.grid_height - 1, self.grid_width - 1])).tolist()\n",
    "\n",
    "        # Compute the reward\n",
    "        reward = 0 if next_agent_location == self.goal_location else -1\n",
    "\n",
    "        # Check the termination\n",
    "        terminated = True if reward == 0 else False\n",
    "\n",
    "        # Update the action location\n",
    "        self.agent_location = next_agent_location\n",
    "        self.action = action\n",
    "\n",
    "        return next_agent_location, reward, terminated, wind_type\n",
    "    \n",
    "    def render(self):\n",
    "        # plot the agent and the goal\n",
    "        # agent = 1\n",
    "        # goal = 2\n",
    "        plot_arr = self.grid.copy()\n",
    "        plot_arr[self.agent_location[0], self.agent_location[1]] = 2\n",
    "        plot_arr[self.goal_location[0], self.goal_location[1]] = 3\n",
    "        plt.clf()\n",
    "        plt.title(f\"state={self.agent_location}, act={self.action}\")\n",
    "        plt.imshow(plot_arr)\n",
    "        plt.show(block=False)\n",
    "        plt.pause(0.5)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implement your modification to Dyna-Q here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" CODE YOUR MODIFICATION TO DYNA-Q HERE:\n",
    "    Tip: you can inherit the Dyna-Q above and change the methods as you wish.\n",
    "\"\"\"\n",
    "\n",
    "\"\"\" We will implement the Dyna-Q as a class that contains the following attributes:\n",
    "        - self.env: an environment object\n",
    "        - self.q_table: a 2-D array with shape (num_state, num_action) that stores the Q values \n",
    "        - self.model: a nested dictionary that stores the past experiences\n",
    "    Note that:\n",
    "        There exists one attribute \"self.maze_switch_time\". It indicates the time to switch from the left maze\n",
    "        to the right maze during the learning process.\n",
    "        \n",
    "    Please complete this class by adding your implementation in the following functions:\n",
    "        - self.update_model\n",
    "        - self.update_q_table\n",
    "        - self.run_planning_step\n",
    "        - self.run\n",
    "              \n",
    "\"\"\"\n",
    "\n",
    "class TabularDynaQAgentWindyGridWorld(object):\n",
    "    def __init__(self, env, info):\n",
    "        # Store the environment\n",
    "        self.env = env\n",
    "\n",
    "        # Store the maximal learning steps\n",
    "        self.k = info['learning_step']\n",
    "\n",
    "        # Store the planning steps\n",
    "        self.n = info['planning_step']\n",
    "\n",
    "        # Store the Q-learning step size alpha\n",
    "        self.alpha = info['alpha']\n",
    "\n",
    "        # Store the discount factor\n",
    "        self.gamma = info['gamma']\n",
    "\n",
    "        # Initialize the epsilon for epsilon-greedy policy\n",
    "        self.epsilon = info['epsilon']\n",
    "\n",
    "        # Initialize the switch time\n",
    "        self.maze_switch_time = info['switch_time_step']\n",
    "        \n",
    "        # Compute total number of the state\n",
    "        self.state_num = len(self.env.observation_space)\n",
    "\n",
    "        # Compute the number of the actions\n",
    "        self.action_num = len(self.env.action_names)\n",
    "\n",
    "        # Initialize the Q(s, a): a table stores (s, a)\n",
    "        self.q_table = np.zeros((self.state_num, self.action_num))\n",
    "\n",
    "        # Initialize the model\n",
    "        # We represent the model as a dictionary of dictionary.\n",
    "        # Specifically, the keys for the outside dictionary is a state tuple (the key should be immutable).\n",
    "        # Given one state tuple key, its value is also a dictionary whose keys are actions names and values are a tuple consisting of (reward, next_state).\n",
    "        # Given an empty model and a transition (s, a, r, s'), the self.model can be updated as\n",
    "        # {s: {a: (r, s')}}.\n",
    "        # E.g. {(0, 0): {'right': (0, [0, 2]), 'left': (0, [0, 0]), ...}, ...}\n",
    "        # We usually call (s, a, r, s') a transition tuple\n",
    "        self.model = {}\n",
    "\n",
    "    def _get_state_idx(self, state):\n",
    "        \"\"\"\n",
    "        Function returns the index of the state in the q table (i.e., row index)\n",
    "        Args:\n",
    "             state (tuple): a tuple contains the state\n",
    "        \"\"\"\n",
    "        state = list(state)\n",
    "        return self.env.observation_space.index(state)\n",
    "\n",
    "    def _get_action_idx(self, action):\n",
    "        \"\"\"\n",
    "        Function returns the index of the action in the q table (i.e., column index)\n",
    "        Args:\n",
    "            action (string): action name\n",
    "        \"\"\"\n",
    "        return self.env.action_names.index(action)\n",
    "\n",
    "    def epsilon_greedy_policy(self, state):\n",
    "        \"\"\"\n",
    "        Function implements the epsilon-greedy policy\n",
    "        Args:\n",
    "            state (tuple): a tuple contains the state\n",
    "        \"\"\"\n",
    "        if random.random() < self.epsilon:  # with p = epsilon, we randomly sample an action\n",
    "            return random.sample(self.env.action_names, 1)[0]\n",
    "        else:  # With p = 1 - epsilon, derive a greedy policy from the Q table\n",
    "            state_idx = self._get_state_idx(state)\n",
    "            q_values = self.q_table[state_idx]\n",
    "            max_action_list = np.where(q_values == q_values.max())[0].tolist()\n",
    "            max_action_idx = random.sample(max_action_list, 1)[0]\n",
    "            return self.env.action_names[max_action_idx]  # break ties\n",
    "\n",
    "                                            #########################\n",
    "                                            ##### MY WORK START #####\n",
    "                                            #########################\n",
    "        \n",
    "    def update_model(self, s, a, r, next_s, w):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            s (list): contains the location of the agent\n",
    "            a (string): name of the action\n",
    "            r (int): reward\n",
    "            next_s (list): contains the location of the agent after taking the action\n",
    "        \"\"\"\n",
    "                \n",
    "        # Want to check for state s, action a, and wind_type w\n",
    "        s_tup = tuple(s)\n",
    "        if s_tup in self.model:\n",
    "            stInModel = True\n",
    "            if a in self.model[s_tup]:\n",
    "                aInModel = True\n",
    "                if w in self.model[s_tup][a]:\n",
    "                    # state, action, and wind type are all in model\n",
    "                    wInModel = True\n",
    "                else:\n",
    "                    # state and action are in model, wind type is not\n",
    "                    wInModel = False\n",
    "            else:\n",
    "                # state in model, action and wind type are not\n",
    "                aInModel = False\n",
    "                wInModel = False\n",
    "        else:\n",
    "            # none in model\n",
    "            stInModel = False\n",
    "            aInModel = False\n",
    "            wInModel = False\n",
    "        \n",
    "        \n",
    "        # update the model by adding the transition as \"tuple s\": {a: {w: (r, next_s)}}\n",
    "        \n",
    "        if stInModel and aInModel and wInModel:\n",
    "            # State, action, w already in model: update with observed reward, s'\n",
    "            self.model[s_tup][a][w] = (r, next_s)\n",
    "        elif stInModel and aInModel and wInModel is False:\n",
    "            # State, action in model, w is not: update model[s][a] with {w: (r, s')}\n",
    "            self.model[s_tup][a].update({w: (r, next_s)})\n",
    "        elif stInModel and aInModel is False and wInModel is False:\n",
    "            # State in model, action and w are not: update model [s] with {a: {w: (r, s')}}\n",
    "            self.model[s_tup].update({a: {w: (r, next_s)}})\n",
    "        elif stInModel is False:\n",
    "            # None exist in the model: create new keys {S: {a: {w: (r, s')}}}\n",
    "            self.model.update({s_tup: {a: {w: (r, next_s)}}})\n",
    "\n",
    "    def update_q_table(self, s, a, r, next_s):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            s (list): contains the location of the agent\n",
    "            a (string): name of the action\n",
    "            r (int): reward\n",
    "            next_s (list): contains the location of the agent after taking the action\n",
    "        \"\"\"\n",
    "        # obtain the table index for s and next_s\n",
    "        s_index = self._get_state_idx(s)\n",
    "        sp_index = self._get_state_idx(next_s)\n",
    "        \n",
    "        # obtain the table index for a\n",
    "        a_index = self._get_action_idx(a)\n",
    "        \n",
    "        # update the Q table\n",
    "        # Q(S, A) = Q(S, A) + alpha*(R + gamma*max_a{Q(S', a)} - Q(S, A))\n",
    "        self.q_table[s_index, a_index] += self.alpha*(r + self.gamma*np.amax(self.q_table[sp_index, :]) - self.q_table[s_index, a_index])\n",
    "\n",
    "    def run_planning_step(self):\n",
    "        for _ in range(self.n):\n",
    "            # randomly sample a previously observe state, you can sample it from the self.model.keys()\n",
    "            state = random.choice(list(self.model.keys()))\n",
    "            \n",
    "            # randomly sample an action previously taken in state, you can sample it from the self.model[state].keys()\n",
    "            action = random.choice(list(self.model[state].keys()))\n",
    "            \n",
    "            # randomly sample a wind type previously taken in state\n",
    "            w_type = random.choice(list(self.model[state][action].keys()))            \n",
    "            \n",
    "            # get reward and s' from model[s][a][w]\n",
    "            reward, next_state = self.model[state][action][w_type]\n",
    "\n",
    "            # update the Q table using Q-learning\n",
    "            self.update_q_table(state, action, reward, next_state)\n",
    "\n",
    "    def run(self):\n",
    "        \n",
    "        # Identify run params\n",
    "        num_episodes = 50\n",
    "        \n",
    "        # Initialize result params\n",
    "        episode_num = 0\n",
    "        t = 0\n",
    "        last_t = t\n",
    "        results = []\n",
    "        \n",
    "        # Dyna-Q starts\n",
    "        state, _ = self.env.reset()\n",
    "        while episode_num < num_episodes:\n",
    "            # derive an action with epsilon-greedy policy\n",
    "            action = self.epsilon_greedy_policy(state)\n",
    "            \n",
    "            # take the action and observe reward, next state, termination status, and wind_type that was taken (if any)\n",
    "            next_state, reward, done, w_type = self.env.step(action)\n",
    "            \n",
    "            # update the Q table using Q-learning\n",
    "            self.update_q_table(state, action, reward, next_state)\n",
    "            \n",
    "            # update model\n",
    "            self.update_model(state, action, reward, next_state, w_type)\n",
    "            \n",
    "            # planning starts\n",
    "            self.run_planning_step()\n",
    "            \n",
    "            # uncomment print info for debug\n",
    "            # print(f\"t = {t}, s = {state}, a = {action}, r = {reward}, next_s = {next_state}, done = {done}\")\n",
    "            \n",
    "            if done:\n",
    "                state, _ = self.env.reset()\n",
    "                steps = t - last_t\n",
    "                results.append(steps)\n",
    "                episode_num += 1\n",
    "                last_t = t\n",
    "            else:\n",
    "                state = next_state\n",
    "            t += 1\n",
    "            \n",
    "        # return results, Q, and observation space to be used below in printing the optimal policy\n",
    "        return results, self.q_table, self.env.observation_space\n",
    "    \n",
    "                                            #######################\n",
    "                                            ##### MY WORK END #####\n",
    "                                            #######################\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\" CODE YOUR SOLUTION TO PLOT THE FIGURE HERE: \n",
    "\"\"\"\n",
    "                                    #######################################\n",
    "                                    ##### EVERYTHING BELOW IS MY WORK #####\n",
    "                                    #######################################\n",
    "# Env\n",
    "env = StochasticWindyGridWorld()\n",
    "\n",
    "# Initialize results array\n",
    "results = np.empty((4, 50))\n",
    "\n",
    "# Run test 4 times with n = {0, 5, 50, 100} to recreate plot similar to Figure 8.2\n",
    "i = 0\n",
    "for n in [0, 5, 50, 100]:\n",
    "    params = {\n",
    "            \"switch_time_step\": 1000,\n",
    "            \"learning_step\": 3000,\n",
    "            \"planning_step\": n,\n",
    "            \"alpha\": 0.1,\n",
    "            \"gamma\": 0.95,\n",
    "            \"epsilon\": 0.1,\n",
    "            \"kappa\": 5e-4\n",
    "        }\n",
    "    \n",
    "    dyna_q_agent = TabularDynaQAgentWindyGridWorld(env, params)\n",
    "    results[i, :], q_table, observation_states = dyna_q_agent.run()\n",
    "    i += 1\n",
    "\n",
    "# Plot results\n",
    "colors = [\"r\", \"g\", \"b\", \"c\"]\n",
    "legend_list = [\"n = 0\", \"n = 5\", \"n = 50\", \"n = 100\"]\n",
    "\n",
    "for row in range(results.shape[0]):\n",
    "    plt.plot(range(results.shape[1]), results[row, :], color = colors[row])\n",
    "plt.legend(legend_list)\n",
    "plt.xlabel(\"Episode #\")\n",
    "plt.ylabel(\"# Steps in Episode\")\n",
    "plt.title(\"Ex6 Q4 - Dyna-Q for Stochastic Windy Gridworld - Luke Davidson\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print out the optimal path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_greedy_policy(observation_states, state, Q):\n",
    "    \"\"\" CODE HERE: How to derive a greedy action using the Q values learned from Dyna-Q\"\"\"\n",
    "    # render the index of the state\n",
    "    s_index = observation_states.index(state)\n",
    "    \n",
    "    # render all q values for state\n",
    "    q_values = Q[s_index, :]\n",
    "    \n",
    "    # find the index of the maximal q values\n",
    "    max_index = np.argmax(q_values)\n",
    "    \n",
    "    # return the action corresponding to the index\n",
    "    action = [\"up\", \"down\", \"left\", \"right\"][max_index]\n",
    "\n",
    "    return action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time step = 0\tState = [3, 0]\tAction = down\tReward = -1\tNext_state = [4, 0]\tDone = False\n",
      "Time step = 1\tState = [4, 0]\tAction = down\tReward = -1\tNext_state = [5, 0]\tDone = False\n",
      "Time step = 2\tState = [5, 0]\tAction = right\tReward = -1\tNext_state = [5, 1]\tDone = False\n",
      "Time step = 3\tState = [5, 1]\tAction = down\tReward = -1\tNext_state = [6, 1]\tDone = False\n",
      "Time step = 4\tState = [6, 1]\tAction = right\tReward = -1\tNext_state = [6, 2]\tDone = False\n",
      "Time step = 5\tState = [6, 2]\tAction = right\tReward = -1\tNext_state = [6, 3]\tDone = False\n",
      "Time step = 6\tState = [6, 3]\tAction = right\tReward = -1\tNext_state = [4, 4]\tDone = False\n",
      "Time step = 7\tState = [4, 4]\tAction = right\tReward = -1\tNext_state = [3, 5]\tDone = False\n",
      "Time step = 8\tState = [3, 5]\tAction = right\tReward = -1\tNext_state = [1, 6]\tDone = False\n",
      "Time step = 9\tState = [1, 6]\tAction = right\tReward = -1\tNext_state = [0, 7]\tDone = False\n",
      "Time step = 10\tState = [0, 7]\tAction = right\tReward = -1\tNext_state = [0, 8]\tDone = False\n",
      "Time step = 11\tState = [0, 8]\tAction = right\tReward = -1\tNext_state = [0, 9]\tDone = False\n",
      "Time step = 12\tState = [0, 9]\tAction = down\tReward = -1\tNext_state = [1, 9]\tDone = False\n",
      "Time step = 13\tState = [1, 9]\tAction = down\tReward = -1\tNext_state = [2, 9]\tDone = False\n",
      "Time step = 14\tState = [2, 9]\tAction = down\tReward = -1\tNext_state = [3, 9]\tDone = False\n",
      "Time step = 15\tState = [3, 9]\tAction = down\tReward = -1\tNext_state = [4, 9]\tDone = False\n",
      "Time step = 16\tState = [4, 9]\tAction = down\tReward = -1\tNext_state = [5, 9]\tDone = False\n",
      "Time step = 17\tState = [5, 9]\tAction = left\tReward = -1\tNext_state = [5, 8]\tDone = False\n",
      "Time step = 18\tState = [5, 8]\tAction = left\tReward = -1\tNext_state = [4, 7]\tDone = False\n",
      "Time step = 19\tState = [4, 7]\tAction = right\tReward = -1\tNext_state = [2, 8]\tDone = False\n",
      "Time step = 20\tState = [2, 8]\tAction = right\tReward = -1\tNext_state = [1, 9]\tDone = False\n",
      "Time step = 21\tState = [1, 9]\tAction = down\tReward = -1\tNext_state = [2, 9]\tDone = False\n",
      "Time step = 22\tState = [2, 9]\tAction = down\tReward = -1\tNext_state = [3, 9]\tDone = False\n",
      "Time step = 23\tState = [3, 9]\tAction = down\tReward = -1\tNext_state = [4, 9]\tDone = False\n",
      "Time step = 24\tState = [4, 9]\tAction = down\tReward = -1\tNext_state = [5, 9]\tDone = False\n",
      "Time step = 25\tState = [5, 9]\tAction = left\tReward = -1\tNext_state = [5, 8]\tDone = False\n",
      "Time step = 26\tState = [5, 8]\tAction = left\tReward = 0\tNext_state = [3, 7]\tDone = True\n"
     ]
    }
   ],
   "source": [
    "# save the Q from the learning above\n",
    "# replace the None with the Q table you obtained.\n",
    "# Tips: you may also need to implement functions to get the index for states and actions. Therefore,\n",
    "# we suggest you to inherit the Dyna-Q above and only modify some methods to deal with the stochastic env.\n",
    "# Assign the learned object of the modified Dyna-Q to Q. You will have the flexibility to render indices and\n",
    "# render Q values, which is an attribute in the object. \n",
    "Q = q_table\n",
    "\n",
    "# create an instance of the env to print the optimal path\n",
    "test_env = StochasticWindyGridWorld()\n",
    "\n",
    "# reset the agent back to the start location\n",
    "state, _ = test_env.reset()\n",
    "\n",
    "for t in range(1000):\n",
    "    \"\"\" CODE HERE: \n",
    "        Implement a function that returns a greedy action (string) based on the current state\n",
    "        using the Q table obtained by the modified Dyna-Q.\n",
    "        Note that, action should be string variable (e.g., \"up\").\n",
    "        Replace the None with your implementation\n",
    "    \"\"\"\n",
    "    action = get_greedy_policy(observation_states, state, Q)\n",
    "    \n",
    "    # interact with the environment\n",
    "    next_state, reward, done, _ = test_env.step(action)\n",
    "    \n",
    "    # print the path\n",
    "    print(f\"Time step = {t}\\tState = {state}\\tAction = {action}\\tReward = {reward}\\tNext_state = {next_state}\\tDone = {done}\")\n",
    "    \n",
    "    # check termination\n",
    "    if done:\n",
    "        break\n",
    "    else:\n",
    "        state = next_state\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}