8-7-reinforcement-learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "730e13fe",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Reinforcement Learning\n",
    "\n",
    "&copy; 李浩东 haodongli@zju.edu.cn\n",
    "\n",
    "- Markov Decision Process (MDP)\n",
    "- Value Iteration\n",
    "- Q-Learning\n",
    "- Deep Q-Learning\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4974f238",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Markov Decision Process (MDP)\n",
    "\n",
    "![rl-loop.png](./images/8/rl-loop.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "599b3250",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Return and Discount Factor\n",
    "\n",
    "![mdp.png](./images/8/mdp.png)\n",
    "\n",
    "- The different components above together form a Markov decision process (MDP)\n",
    "\n",
    "$$\\text{MDP}: (\\mathcal{S}, \\mathcal{A}, T, r).$$\n",
    "\n",
    "- Let's now consider the situation when the robot starts at a particular state $s_0 \\in \\mathcal{S}$ and continues taking actions to result in a trajectory\n",
    "\n",
    "$$\\tau = (s_0, a_0, r_0, s_1, a_1, r_1, s_2, a_2, r_2, \\ldots).$$\n",
    "\n",
    "- At each time step $t$ the robot is at a state $s_t$ and takes an action $a_t$ which results in a reward $r_t = r(s_t, a_t)$. The *return* of a trajectory is the total reward obtained by the robot along such a trajectory\n",
    "\n",
    "$$R(\\tau) = r_0 + r_1 + r_2 + \\cdots.$$\n",
    "\n",
    "- **The goal in reinforcement learning is to find a trajectory that has the largest *return*.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7123350",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![mdp.png](./images/8/mdp.png)\n",
    "\n",
    "\n",
    "- Think of the situation when the robot continues to travel in the gridworld without ever reaching the goal location. The sequence of states and actions in a trajectory can be infinitely long in this case and the *return* of any such infinitely long trajectory will be infinite. In order to keep the reinforcement learning formulation meaningful even for such trajectories, we introduce the notion of a discount factor $\\gamma < 1$. We write the discounted *return* as\n",
    "\n",
    "$$R(\\tau) = r_0 + \\gamma r_1 + \\gamma^2 r_2 + \\cdots = \\sum_{t=0}^\\infty \\gamma^t r_t.$$\n",
    "\n",
    "- Note that if $\\gamma$ is very small, the rewards earned by the robot in the far future, say $t = 1000$, are heavily discounted by the factor $\\gamma^{1000}$. This **encourages the robot to select short trajectories that achieve its goal**, namely that of going to the green house in the gridwold example. For large values of the discount factor, say $\\gamma = 0.99$, **the robot is encouraged to *explore*** and then find the best trajectory to go to the goal location."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab508847",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Value Iteration\n",
    "\n",
    "![mdp.png](./images/8/mdp.png)\n",
    "\n",
    "- Imagine now that the robot starts at a state $s_0$ and at each time instant, it first samples an action from the policy $a_t \\sim \\pi(s_t)$ and takes this action to result in the next state $s_{t+1}$. The trajectory $\\tau = (s_0, a_0, r_0, s_1, a_1, r_1, \\ldots)$, can be different depending upon which particular action $a_t$ is sampled at intermediate instants. We define the average *return* $R(\\tau) = \\sum_{t=0}^\\infty \\gamma^t r(s_t, a_t)$ of all such trajectories\n",
    "\n",
    "$$V^\\pi(s_0) = E_{a_t \\sim \\pi(s_t)} \\Big[ R(\\tau) \\Big] = E_{a_t \\sim \\pi(s_t)} \\Big[ \\sum_{t=0}^\\infty \\gamma^t r(s_t, a_t) \\Big],$$\n",
    "\n",
    "- where $s_{t+1} \\sim P(s_{t+1} \\mid s_t, a_t)$ is the next state of the robot and $r(s_t, a_t)$ is the instantaneous reward obtained by taking action $a_t$ in state $s_t$ at time $t$. This is called the \"value function\" for the policy $\\pi$. In simple words, the value of a state $s_0$ for a policy $\\pi$, denoted by $V^\\pi(s_0)$, is the expected $\\gamma$-discounted *return* obtained by the robot if it begins at state $s_0$ and takes actions from the policy $\\pi$ at each time instant.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae895bdb",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- We next break down the trajectory into two stages \n",
    "    - (i) the first stage which corresponds to $s_0 \\to s_1$ upon taking the action $a_0$, and \n",
    "    - (ii) a second stage which is the trajectory $\\tau' = (s_1, a_1, r_1, \\ldots)$ thereafter. \n",
    "- The key idea behind all algorithms in reinforcement learning is that **the value of state $s_0$ can be written as the average reward obtained in the first stage and the value function averaged over all possible next states $s_1$**. This is quite intuitive and arises from our Markov assumption: the average return from the current state is the sum of the average return from the next state and the average reward of going to the next state. \n",
    "- Mathematically, we write the two stages as\n",
    "\n",
    "$$V^\\pi(s_0) = r(s_0, a_0) + \\gamma\\ E_{a_0 \\sim \\pi(s_0)} \\Big[ E_{s_1 \\sim P(s_1 \\mid s_0, a_0)} \\Big[ V^\\pi(s_1) \\Big] \\Big].$$\n",
    "\n",
    "- Then using the transition probabilities in the Markov decision process (MDP), we can write\n",
    "\n",
    "$$V^\\pi(s) = \\sum_{a \\in \\mathcal{A}} \\pi(a \\mid s) \\Big[ r(s,  a) + \\gamma\\  \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) V^\\pi(s') \\Big];\\ \\text{for all } s \\in \\mathcal{S}.$$\n",
    "\n",
    "- An important thing to notice here is that the above identity holds for all states $s \\in \\mathcal{S}$ because we can think of any trajectory that begins at that state and break down the trajectory into two stages."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6968054c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Action-Value Function\n",
    "\n",
    "- In implementations, it is often useful to maintain a quantity called the \"action value\" function which is a closely related quantity to the value function. This is defined to be the average *return* of a trajectory that begins at $s_0$ but when the action of the first stage is fixed to be $a_0$\n",
    "\n",
    "$$Q^\\pi(s_0, a_0) = r(s_0, a_0) + E_{a_t \\sim \\pi(s_t)} \\Big[ \\sum_{t=1}^\\infty \\gamma^t r(s_t, a_t) \\Big],$$\n",
    "\n",
    "- note that the summation inside the expectation is from $t=1,\\ldots, \\infty$ because the reward of the first stage is fixed in this case. We can again break down the trajectory into two parts and write\n",
    "\n",
    "$$Q^\\pi(s, a) = r(s, a) + \\gamma \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) \\sum_{a' \\in \\mathcal{A}} \\pi(a' \\mid s')\\ Q^\\pi(s', a');\\ \\text{ for all } s \\in \\mathcal{S}, a \\in \\mathcal{A}.$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "226624db",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Optimal Stochastic Policy\n",
    "\n",
    "- Both the value function and the action-value function depend upon the policy that the robot chooses. We will next think of the \"optimal policy\" that achieves the maximal average *return*\n",
    "\n",
    "$$\\pi^* = \\underset{\\pi}{\\mathrm{argmax}} V^\\pi(s_0).$$\n",
    "\n",
    "- Of all possible stochastic policies that the robot could have taken, the optimal policy $\\pi^*$  achieves the largest average discounted *return* for trajectories starting from state $s_0$. Let us denote the value function and the action-value function of the optimal policy as $V^* \\equiv V^{\\pi^*}$ and $Q^* \\equiv Q^{\\pi^*}$.\n",
    "\n",
    "- Let us observe that for a deterministic policy where there is only one action that is possible under the policy at any given state. This gives us\n",
    "\n",
    "$$\\pi^*(s) = \\underset{a \\in \\mathcal{A}}{\\mathrm{argmax}} \\Big[ r(s, a) + \\gamma \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a)\\ V^*(s') \\Big].$$\n",
    "\n",
    "- A good mnemonic to remember this is that the optimal action at state $s$ (for a deterministic policy) is the one that **maximizes the sum of reward $r(s, a)$ from the first stage and the average *return* of the trajectories starting from the next sate $s'$, averaged over all possible next states $s'$ from the second stage**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfa07570",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Principle of Dynamic Programming\n",
    "\n",
    "- Our developement in the previous section in :eqref:`eq_dynamic_programming` or :eqref:`eq_dynamic_programming_q` can be turned into an algorithm to compute the optimal value function $V^*$ or the action-value function $Q^*$, respectively. Observe that\n",
    "\n",
    "$$ V^*(s) = \\sum_{a \\in \\mathcal{A}} \\pi^*(a \\mid s) \\Big[ r(s,  a) + \\gamma\\  \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) V^*(s') \\Big];\\ \\text{for all } s \\in \\mathcal{S}.$$\n",
    "\n",
    "- For a deterministic optimal policy $\\pi^*$, since there is only one action that can be taken at state $s$, we can also write \n",
    "\n",
    "$$V^*(s) = \\mathrm{argmax}_{a \\in \\mathcal{A}} \\Big\\{ r(s,a) + \\gamma \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) V^*(s') \\Big\\}$$\n",
    "\n",
    "- for all states $s \\in \\mathcal{S}$. This identity is called the \"principle of dynamic programming\". It was formulated by Richard Bellman in 1950s and we can remember it as \"the remainder of an optimal trajectory is also optimal\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08018a85",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Value Iteration\n",
    "\n",
    "- We can turn the principle of dynamic programming into an algorithm for finding the optimal value function called value iteration. The key idea behind value iteration is to think of this identity as a set of constraints that tie together $V^*(s)$ at different states $s \\in \\mathcal{S}$. We initialize the value function to some arbitrary values $V_0(s)$ for all states $s \\in \\mathcal{S}$. At the $k^{\\text{th}}$ iteration, the Value Iteration algorithm updates the value function as\n",
    "\n",
    "$$V_{k+1}(s) = \\max_{a \\in \\mathcal{A}} \\Big\\{ r(s,  a) + \\gamma\\  \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) V_k(s') \\Big\\};\\ \\text{for all } s \\in \\mathcal{S}.$$\n",
    "\n",
    "- It turns out that as $k \\to \\infty$ the value function estimated by the Value Iteration algorithm converges to the optimal value function irrespective of the initialization $V_0$,\n",
    "\n",
    "$$V^*(s) = \\lim_{k \\to \\infty} V_k(s);\\ \\text{for all states } s \\in \\mathcal{S}.$$\n",
    "\n",
    "- The same Value Iteration algorithm can be equivalently written using the action-value function as\n",
    "\n",
    "$$Q_{k+1}(s, a) = r(s, a) + \\gamma \\max_{a' \\in \\mathcal{A}} \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) Q_k (s', a');\\ \\text{ for all } s \\in \\mathcal{S}, a \\in \\mathcal{A}.$$\n",
    "\n",
    "- In this case we initialize $Q_0(s, a)$ to some arbitrary values for all $s \\in \\mathcal{S}$ and $a \\in \\mathcal{A}$. Again we have $Q^*(s, a) = \\lim_{k \\to \\infty} Q_k(s, a)$ for all $s \\in \\mathcal{S}$ and $a \\in \\mathcal{A}$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4580344",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Policy Evaluation\n",
    "\n",
    "- Value Iteration enables us to compute the optimal value function, i.e., $V^{\\pi^*}$ of the optimal deterministic policy $\\pi^*$. We can also use similar iterative updates to compute the value function associated with any other, potentially stochastic, policy $\\pi$. We again initialize $V^\\pi_0(s)$ to some arbitrary values for all states $s \\in \\mathcal{S}$ and at the $k^{\\text{th}}$ iteration, perform the updates\n",
    "\n",
    "$$    V^\\pi_{k+1}(s) = \\sum_{a \\in \\mathcal{A}} \\pi(a \\mid s) \\Big[ r(s,  a) + \\gamma\\  \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) V^\\pi_k(s') \\Big];\\ \\text{for all } s \\in \\mathcal{S}.$$\n",
    "\n",
    "- This algorithm is known as policy evaluation and is useful to compute the value function given the policy. Again, it turns out that as $k \\to \\infty$ these updates converge to the correct value function irrespective of the initialization $V_0$,\n",
    "\n",
    "$$V^\\pi(s) = \\lim_{k \\to \\infty} V^\\pi_k(s);\\ \\text{for all states } s \\in \\mathcal{S}.$$\n",
    "\n",
    "- The algorithm for computing the action-value function $Q^\\pi(s, a)$ of a policy $\\pi$ is analogous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c159a8c4",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: gym==0.21.0 in /home/haodong/Applications/Miniconda/Miniconda/envs/dl/lib/python3.9/site-packages (0.21.0)\r\n",
      "Requirement already satisfied: numpy>=1.18.0 in /home/haodong/Applications/Miniconda/Miniconda/envs/dl/lib/python3.9/site-packages (from gym==0.21.0) (1.22.3)\r\n",
      "Requirement already satisfied: cloudpickle>=1.2.0 in /home/haodong/Applications/Miniconda/Miniconda/envs/dl/lib/python3.9/site-packages (from gym==0.21.0) (2.2.0)\r\n"
     ]
    }
   ],
   "source": [
    "!pip install gym==0.21.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f381db0e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import random\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import gym\n",
    "\n",
    "seed = 0  # Random number generator seed\n",
    "gamma = 0.95  # Discount factor\n",
    "num_iters = 10  # Number of iterations\n",
    "random.seed(seed)  # Set the random seed to ensure results can be reproduced\n",
    "np.random.seed(seed)\n",
    "\n",
    "def frozen_lake(seed):\n",
    "    \"\"\"Defined in :numref:`sec_utils`\"\"\"\n",
    "    # See https://www.gymlibrary.dev/environments/toy_text/frozen_lake/ to learn more about this env\n",
    "    # How to process env.P.items is adpated from https://sites.google.com/view/deep-rl-bootcamp/labs\n",
    "\n",
    "    env = gym.make('FrozenLake-v1', is_slippery=False)\n",
    "    env.seed(seed)\n",
    "    env.action_space.np_random.seed(seed)\n",
    "    env.action_space.seed(seed)\n",
    "    env_info = {}\n",
    "    env_info['desc'] = env.desc  # 2D array specifying what each grid item means\n",
    "    env_info['num_states'] = env.nS  # Number of observations/states or obs/state dim\n",
    "    env_info['num_actions'] = env.nA  # Number of actions or action dim\n",
    "    # Define indices for (transition probability, nextstate, reward, done) tuple\n",
    "    env_info['trans_prob_idx'] = 0  # Index of transition probability entry\n",
    "    env_info['nextstate_idx'] = 1  # Index of next state entry\n",
    "    env_info['reward_idx'] = 2  # Index of reward entry\n",
    "    env_info['done_idx'] = 3  # Index of done entry\n",
    "    env_info['mdp'] = {}\n",
    "    env_info['env'] = env\n",
    "\n",
    "    for (s, others) in env.P.items():\n",
    "        # others(s) = {a0: [ (p(s'|s,a0), s', reward, done),...], a1:[...], ...}\n",
    "\n",
    "        for (a, pxrds) in others.items():\n",
    "            # pxrds is [(p1,next1,r1,d1),(p2,next2,r2,d2),..].\n",
    "            # e.g. [(0.3, 0, 0, False), (0.3, 0, 0, False), (0.3, 4, 1, False)]\n",
    "            env_info['mdp'][(s,a)] = pxrds\n",
    "\n",
    "    return env_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "183723d8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def show_value_function_progress(env_desc, V, pi):\n",
    "    \"\"\"Defined in :numref:`sec_utils`\"\"\"\n",
    "    # This function visualizes how value and policy changes over time.\n",
    "    # V: [num_iters, num_states]\n",
    "    # pi: [num_iters, num_states]\n",
    "    # How to visualize value function is adapted (but changed) from: https://sites.google.com/view/deep-rl-bootcamp/labs\n",
    "\n",
    "    num_iters = V.shape[0]\n",
    "    fig, ax  = plt.subplots(figsize=(15, 15))\n",
    "\n",
    "    for k in range(V.shape[0]):\n",
    "        plt.subplot(4, 4, k + 1)\n",
    "        plt.imshow(V[k].reshape(4,4), cmap=\"bone\")\n",
    "        ax = plt.gca()\n",
    "        ax.set_xticks(np.arange(0, 5)-.5, minor=True)\n",
    "        ax.set_yticks(np.arange(0, 5)-.5, minor=True)\n",
    "        ax.grid(which=\"minor\", color=\"w\", linestyle='-', linewidth=3)\n",
    "        ax.tick_params(which=\"minor\", bottom=False, left=False)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "\n",
    "        # LEFT action: 0, DOWN action: 1\n",
    "        # RIGHT action: 2, UP action: 3\n",
    "        action2dxdy = {0:(-.25, 0),1: (0, .25),\n",
    "                       2:(0.25, 0),3: (-.25, 0)}\n",
    "\n",
    "        for y in range(4):\n",
    "            for x in range(4):\n",
    "                action = pi[k].reshape(4,4)[y, x]\n",
    "                dx, dy = action2dxdy[action]\n",
    "\n",
    "                if env_desc[y,x].decode() == 'H':\n",
    "                    ax.text(x, y, str(env_desc[y,x].decode()),\n",
    "                       ha=\"center\", va=\"center\", color=\"y\",\n",
    "                         size=20, fontweight='bold')\n",
    "\n",
    "                elif env_desc[y,x].decode() == 'G':\n",
    "                    ax.text(x, y, str(env_desc[y,x].decode()),\n",
    "                       ha=\"center\", va=\"center\", color=\"w\",\n",
    "                         size=20, fontweight='bold')\n",
    "\n",
    "                else:\n",
    "                    ax.text(x, y, str(env_desc[y,x].decode()),\n",
    "                       ha=\"center\", va=\"center\", color=\"g\",\n",
    "                         size=15, fontweight='bold')\n",
    "\n",
    "                # No arrow for cells with G and H labels\n",
    "                if env_desc[y,x].decode() != 'G' and env_desc[y,x].decode() != 'H':\n",
    "                    ax.arrow(x, y, dx, dy, color='r', head_width=0.2, head_length=0.15)\n",
    "\n",
    "        ax.set_title(\"Step = \"  + str(k + 1), fontsize=20)\n",
    "\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4cbc2bae",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Now set up the environment\n",
    "env_info = frozen_lake(seed)\n",
    "\n",
    "def value_iteration(env_info, gamma, num_iters):\n",
    "    env_desc = env_info['desc']  # 2D array shows what each item means\n",
    "    prob_idx = env_info['trans_prob_idx']\n",
    "    nextstate_idx = env_info['nextstate_idx']\n",
    "    reward_idx = env_info['reward_idx']\n",
    "    num_states = env_info['num_states']\n",
    "    num_actions = env_info['num_actions']\n",
    "    mdp = env_info['mdp']\n",
    "\n",
    "    V  = np.zeros((num_iters + 1, num_states))\n",
    "    Q  = np.zeros((num_iters + 1, num_states, num_actions))\n",
    "    pi = np.zeros((num_iters + 1, num_states))\n",
    "\n",
    "    for k in range(1, num_iters + 1):\n",
    "        for s in range(num_states):\n",
    "            for a in range(num_actions):\n",
    "                # Calculate \\sum_{s'} p(s'\\mid s,a) [r + \\gamma v_k(s')]\n",
    "                for pxrds in mdp[(s,a)]:\n",
    "                    # mdp(s,a): [(p1,next1,r1,d1),(p2,next2,r2,d2),..]\n",
    "                    pr = pxrds[prob_idx]  # p(s'\\mid s,a)\n",
    "                    nextstate = pxrds[nextstate_idx]  # Next state\n",
    "                    reward = pxrds[reward_idx]  # Reward\n",
    "                    Q[k,s,a] += pr * (reward + gamma * V[k - 1, nextstate])\n",
    "            # Record max value and max action\n",
    "            V[k,s] = np.max(Q[k,s,:])\n",
    "            pi[k,s] = np.argmax(Q[k,s,:])\n",
    "    show_value_function_progress(env_desc, V[:-1], pi[:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "765811de",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "value_iteration(env_info=env_info, gamma=gamma, num_iters=num_iters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f186ab2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Q-Learning\n",
    "\n",
    "### The Q-Learning Algorithm\n",
    "\n",
    "- Recall that value iteration for the action-value function in :ref:`sec_valueiter` corresponds to the update\n",
    "\n",
    "$$Q_{k+1}(s, a) = r(s, a) + \\gamma \\sum_{s' \\in \\mathcal{S}} P(s' \\mid s, a) \\max_{a' \\in \\mathcal{A}} Q_k (s', a'); \\ \\text{for all } s \\in \\mathcal{S} \\text{ and } a \\in \\mathcal{A}.$$\n",
    "\n",
    "- As we discussed, implementing this algorithm requires knowing the MDP, specifically the transition function $P(s' \\mid s, a)$. The key idea behind Q-Learning is to **replace the summation over all $s' \\in \\mathcal{S}$ in the above expression by a summation over the states visited by the robot**. This allows us to subvert the need to know the transition function.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c3f5c5a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### An Optimization Problem Underlying Q-Learning\n",
    "\n",
    "- Let us imagine that the robot uses a policy $\\pi_e(a \\mid s)$ to take actions. Just like the previous chapter, it collects a dataset of $n$ trajectories of $T$ timesteps each $\\{ (s_t^i, a_t^i)_{t=0,\\ldots,T-1}\\}_{i=1,\\ldots, n}$. Recall that value iteration is really a set of constraints that ties together the action-value $Q^*(s, a)$ of different states and actions to each other. We can implement an approximate version of value iteration using the data that the robot has collected using $\\pi_e$ as\n",
    "\n",
    "$$\\hat{Q} = \\min_Q \\underbrace{\\frac{1}{nT} \\sum_{i=1}^n \\sum_{t=0}^{T-1} (Q(s_t^i, a_t^i) - r(s_t^i, a_t^i) - \\gamma \\max_{a'} Q(s_{t+1}^i, a'))^2}_{\\stackrel{\\mathrm{def}}{=} \\ell(Q)}.$$\n",
    "\n",
    "- The variables of our optimization problem are $Q(s, a)$ for all $s \\in \\mathcal{S}$ and $a \\in \\mathcal{A}$. We can minimize the objective using gradient descent. For every pair $(s_t^i, a_t^i)$ in our dataset, we can write\n",
    "\n",
    "$$\\begin{aligned}Q(s_t^i, a_t^i) &\\leftarrow Q(s_t^i, a_t^i) - \\alpha \\nabla_{Q(s_t^i,a_t^i)} \\ell(Q) \\\\&=(1 - \\alpha) Q(s_t^i,a_t^i) - \\alpha \\Big( r(s_t^i, a_t^i) + \\gamma \\max_{a'} Q(s_{t+1}^i, a') \\Big),\\end{aligned}$$\n",
    "\n",
    "- where $\\alpha$ is the learning rate. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2b986a3",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Typically in real problems, when the robot reaches the goal location, the trajectories end. The value of such a terminal state is zero because the robot does not take any further actions beyond this state. We should modify our update to handle such states as\n",
    "\n",
    "$$Q(s_t^i, a_t^i) =(1 - \\alpha) Q(s_t^i,a_t^i) - \\alpha \\Big( r(s_t^i, a_t^i) + \\gamma (1 - \\mathbb{1}_{s_{t+1}^i \\text{ is terminal}} )\\max_{a'} Q(s_{t+1}^i, a') \\Big).$$\n",
    "\n",
    "- where $\\mathbb{1}_{s_{t+1}^i \\text{ is terminal}}$ is an indicator variable that is one if $s_{t+1}^i$ is a terminal state and zero otherwise. \n",
    "- The value of state-action tuples $(s, a)$ that are not a part of the dataset is set to $-\\infty$. This algorithm is known as Q-Learning.\n",
    "\n",
    "- Given the solution of these updates $\\hat{Q}$, which is an approximation of the optimal value function $Q^*$, we can obtain the optimal deterministic policy corresponding to this value function easily using\n",
    "\n",
    "$$\\hat{\\pi}(s) = \\mathrm{argmax}_{a} \\hat{Q}(s, a).$$\n",
    "\n",
    "- There can be situations when there are multiple deterministic policies that correspond to the same optimal value function; such ties can be broken arbitrarily because they have the same value function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c25d090",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exploration in Q-Learning\n",
    "\n",
    "- The policy used by the robot to collect data $\\pi_e$ is critical to ensure that Q-Learning works well. Afterall, we have replaced the expectation over $s'$ using the transition function $P(s' \\mid s, a)$ using the data collected by the robot. \n",
    "- If the policy $\\pi_e$ does **not reach diverse parts of the state-action space**, then it is easy to imagine our estimate $\\hat{Q}$ will be a poor approximation of the optimal $Q^*$. It is also important to note that in such a situation, the estimate of $Q^*$ at *all states* $s \\in \\mathcal{S}$ will be bad, not just the ones visited by $\\pi_e$. This is because the Q-Learning objective (or value iteration) is **a constraint that ties together the value of all state-action pairs**. It is therefore critical to pick the correct policy $\\pi_e$ to collect data.\n",
    "\n",
    "- We can mitigate this concern by picking a completely random policy $\\pi_e$ that samples actions uniformly randomly from $\\mathcal{A}$. Such a policy would visit all states, but it will take a large number of trajectories before it does so.\n",
    "\n",
    "- We thus arrive at the second key idea in Q-Learning, namely exploration. Typical implementations of Q-Learning tie together the current estimate of $Q$ and the policy $\\pi_e$ to set\n",
    "\n",
    "$$\\pi_e(a \\mid s) = \\begin{cases}\\mathrm{argmax}_{a'} \\hat{Q}(s, a') & \\text{with prob. } 1-\\epsilon \\\\ \\text{uniform}(\\mathcal{A}) & \\text{with prob. } \\epsilon,\\end{cases}$$\n",
    "\n",
    "- where $\\epsilon$ is called the \"exploration parameter\" and is chosen by the user. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67d2027b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- The policy $\\pi_e$ is called an exploration policy. This particular $\\pi_e$ is called an $\\epsilon$-greedy exploration policy because it chooses the optimal action (under the current estimate $\\hat{Q}$) with probability $1-\\epsilon$ but explores randomly with the remainder probability $\\epsilon$. We can also use the so-called softmax exploration policy\n",
    "\n",
    "$$\\pi_e(a \\mid s) = \\frac{e^{\\hat{Q}(s, a)/T}}{\\sum_{a'} e^{\\hat{Q}(s, a')/T}};$$\n",
    "\n",
    "- where the hyper-parameter $T$ is called temperature. A large value of $\\epsilon$ in $\\epsilon$-greedy policy functions similarly to a large value of temperature $T$ for the softmax policy.\n",
    "\n",
    "- It is important to note that when we pick an exploration that depends upon the current estimate of the action-value function $\\hat{Q}$, we need to resolve the optimization problem periodically. Typical implementations of Q-Learning make one mini-batch update using a few state-action pairs in the collected dataset (typically the ones collected from the previous timestep of the robot) after taking every action using $\\pi_e$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5242968d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The \"Self-correcting\" Property of Q-Learning\n",
    "\n",
    "- Consider a state $s$: if a particular action $a$ has a large value under the current estimate $\\hat{Q}(s,a)$, then both the $\\epsilon$-greedy and the softmax exploration policies have a larger probability of picking this action. \n",
    "- If this action actually is *not* the ideal action, then the future states that arise from this action will have poor rewards. The next update of the Q-Learning objective will therefore reduce the value $\\hat{Q}(s,a)$, which will reduce the probability of picking this action the next time the robot visits state $s$. Bad actions, e.g., ones whose value is overestimated in $\\hat{Q}(s,a)$, are explored by the robot but their value is correct in the next update of the Q-Learning objective. Good actions, e.g., whose value $\\hat{Q}(s, a)$ is large, are explored more often by the robot and thereby reinforced. \n",
    "\n",
    "- This ability to **not only collect new data but also collect the right kind of data** is the central feature of reinforcement learning algorithms, and this is what distinguishes them from supervised learning. Q-Learning, using deep neural networks (which we will see in the DQN chapeter later), is responsible for the resurgence of reinforcement learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e2c20254",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "seed = 0  # Random number generator seed\n",
    "gamma = 0.95  # Discount factor\n",
    "num_iters = 256  # Number of iterations\n",
    "alpha   = 0.9  # Learing rate\n",
    "epsilon = 0.9  # Epsilon in epsilion gready algorithm\n",
    "random.seed(seed)  # Set the random seed\n",
    "np.random.seed(seed)\n",
    "\n",
    "# Now set up the environment\n",
    "env_info = frozen_lake(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d38fc088",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def show_Q_function_progress(env_desc, V_all, pi_all):\n",
    "    \"\"\"Defined in :numref:`sec_utils`\"\"\"\n",
    "    # This function visualizes how value and policy changes over time.\n",
    "    # V: [num_iters, num_states]\n",
    "    # pi: [num_iters, num_states]\n",
    "\n",
    "    # We want to only shows few values\n",
    "    num_iters_all = V_all.shape[0]\n",
    "    num_iters = num_iters_all // 10\n",
    "\n",
    "    vis_indx = np.arange(0, num_iters_all, num_iters).tolist()\n",
    "    vis_indx.append(num_iters_all - 1)\n",
    "    V = np.zeros((len(vis_indx), V_all.shape[1]))\n",
    "    pi = np.zeros((len(vis_indx), V_all.shape[1]))\n",
    "\n",
    "    for c, i in enumerate(vis_indx):\n",
    "        V[c]  = V_all[i]\n",
    "        pi[c] = pi_all[i]\n",
    "\n",
    "    num_iters = V.shape[0]\n",
    "    fig, ax = plt.subplots(figsize=(15, 15))\n",
    "\n",
    "    for k in range(V.shape[0]):\n",
    "        plt.subplot(4, 4, k + 1)\n",
    "        plt.imshow(V[k].reshape(4,4), cmap=\"bone\")\n",
    "        ax = plt.gca()\n",
    "        ax.set_xticks(np.arange(0, 5)-.5, minor=True)\n",
    "        ax.set_yticks(np.arange(0, 5)-.5, minor=True)\n",
    "        ax.grid(which=\"minor\", color=\"w\", linestyle='-', linewidth=3)\n",
    "        ax.tick_params(which=\"minor\", bottom=False, left=False)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "\n",
    "        # LEFT action: 0, DOWN action: 1\n",
    "        # RIGHT action: 2, UP action: 3\n",
    "        action2dxdy = {0:(-.25, 0),1:(0, .25),\n",
    "                       2:(0.25, 0),3:(-.25, 0)}\n",
    "\n",
    "        for y in range(4):\n",
    "            for x in range(4):\n",
    "                action = pi[k].reshape(4,4)[y, x]\n",
    "                dx, dy = action2dxdy[action]\n",
    "\n",
    "                if env_desc[y,x].decode() == 'H':\n",
    "                    ax.text(x, y, str(env_desc[y,x].decode()),\n",
    "                       ha=\"center\", va=\"center\", color=\"y\",\n",
    "                         size=20, fontweight='bold')\n",
    "\n",
    "                elif env_desc[y,x].decode() == 'G':\n",
    "                    ax.text(x, y, str(env_desc[y,x].decode()),\n",
    "                       ha=\"center\", va=\"center\", color=\"w\",\n",
    "                         size=20, fontweight='bold')\n",
    "\n",
    "                else:\n",
    "                    ax.text(x, y, str(env_desc[y,x].decode()),\n",
    "                       ha=\"center\", va=\"center\", color=\"g\",\n",
    "                         size=15, fontweight='bold')\n",
    "\n",
    "                # No arrow for cells with G and H labels\n",
    "                if env_desc[y,x].decode() != 'G' and env_desc[y,x].decode() != 'H':\n",
    "                    ax.arrow(x, y, dx, dy, color='r', head_width=0.2, head_length=0.15)\n",
    "\n",
    "        ax.set_title(\"Step = \"  + str(vis_indx[k] + 1), fontsize=20)\n",
    "\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9c763ef1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def e_greedy(env, Q, s, epsilon):\n",
    "    if random.random() < epsilon:\n",
    "        return env.action_space.sample()\n",
    "\n",
    "    else:\n",
    "        return np.argmax(Q[s,:])\n",
    "\n",
    "def q_learning(env_info, gamma, num_iters, alpha, epsilon):\n",
    "    env_desc = env_info['desc']  # 2D array specifying what each grid item means\n",
    "    env = env_info['env']  # 2D array specifying what each grid item means\n",
    "    num_states = env_info['num_states']\n",
    "    num_actions = env_info['num_actions']\n",
    "\n",
    "    Q  = np.zeros((num_states, num_actions))\n",
    "    V  = np.zeros((num_iters + 1, num_states))\n",
    "    pi = np.zeros((num_iters + 1, num_states))\n",
    "\n",
    "    for k in range(1, num_iters + 1):\n",
    "        # Reset environment\n",
    "        state, done = env.reset(), False\n",
    "        while not done:\n",
    "            # Select an action for a given state and acts in env based on selected action\n",
    "            action = e_greedy(env, Q, state, epsilon)\n",
    "            next_state, reward, done, _ = env.step(action)\n",
    "\n",
    "            # Q-update:\n",
    "            y = reward + gamma * np.max(Q[next_state,:])\n",
    "            Q[state, action] = Q[state, action] + alpha * (y - Q[state, action])\n",
    "\n",
    "            # Move to the next state\n",
    "            state = next_state\n",
    "        # Record max value and max action for visualization purpose only\n",
    "        for s in range(num_states):\n",
    "            V[k,s]  = np.max(Q[s,:])\n",
    "            pi[k,s] = np.argmax(Q[s,:])\n",
    "    show_Q_function_progress(env_desc, V[:-1], pi[:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a431de9c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "q_learning(env_info=env_info, gamma=gamma, num_iters=num_iters, alpha=alpha, epsilon=epsilon)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "547f94ea",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Deep Q-Learning\n",
    "\n",
    "- https://github.com/fg91/Deep-Q-Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72c2bf9c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Dueling Networks\n",
    "\n",
    "![dueling](./images/8/dueling.png)\n",
    "\n",
    "- In the normal DQN architecture (top network in the figure) the *final hidden layer is fully-connected and consists of 512 rectifier units. The output layer is a fully-connected linear layer with a single output for each valid action.* (see page 6 of [Mnih et al. 2015](https://www.nature.com/articles/nature14236/)) \n",
    "\n",
    "- These outputs are the predicted $Q(s,a;\\theta)$-values for action $a$ in state $s$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18388654",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Dueling Networks\n",
    "\n",
    "![dueling](./images/8/dueling.png)\n",
    "\n",
    "- Instead of directly predicting a single $Q$-value for each action, the dueling architecture splits the final convolutional layer into two streams that represent the value and advantage functions that predict a *state value* $V(s)$ that depends only on the state, and *action advantages* $A(s,a)$ that depend on the state and the respective action. On page 2 of [Wang et al. 2016](https://arxiv.org/abs/1511.06581) the authors explain:\n",
    "\n",
    ">Intuitively, the dueling architecture can learn which states are (or are not) valuable, without having to learn the effect of each action for each state. This is particularly useful in states where its actions do not affect the environment in any relevant way. \n",
    "In the experiments, we demonstrate that the dueling architecture can more quickly identify the correct action during policy evaluation as redundant or similar actions are added to the learning problem. \n",
    "\n",
    "- The *state value* $V(s)$ predicts *how good it is to be in a certain state* $s$ and the *action advantage* $A(s,a)$ predicts *how good it is to perform action $a$ in state $s$*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcee6110",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Next, we have to combine the value and advantage stream into $Q$-values $Q(s,a)$. This is done the following way (equation 9 in [Wang et al. 2016](https://arxiv.org/abs/1511.06581)):\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "Q(s,a) = V(s) + \\left(A(s,a) - \\frac 1{| \\mathcal A |}\\sum_{a'}A(s, a')\\right)\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "- Why so complicated instead of just adding $V(s)$ and $A(s,a)$? Let's assume $Q(s,a) = V(s) + \\mathbf{A}(s,a), \\quad \\mathbf{A}=\\left(A(s,a) - \\frac 1{| \\mathcal A |}\\sum_{a'}A(s, a')\\right)$:\n",
    "\n",
    "- The Q function measures the value of choosing a particular action when in a particular state. The value function $V$, which is the expected value of $Q$ over all possible actions, $V = E(Q)$, measures how good it is to be in this particular state. \n",
    "\n",
    "- If you combine $E(Q) = V$ and $Q = V + \\mathbf{A}$, you find $E(Q) = E(V) + E(\\mathbf{A})$. But $V$ does not depend on any action, which means $E(V)=V$, $E(Q) = V + E(\\mathbf{A}) = V$ and thus $E(\\mathbf{A})=0$. The expected value of $\\mathbf{A}$ is zero because we subtract the mean of the advantages from every advantage:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "E(\\mathbf{A})=E\\left(A(s,a) - \\frac 1{| \\mathcal A |}\\sum_{a'}A(s, a')\\right) = E\\Bigl(A - E(A)\\Bigr) = E(A)- E(E(A)) = E(A) - E(A) = 0\n",
    "\\end{equation}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12795e85",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](./images/8/DQN.png)\n",
    "\n",
    "* The problem is that both $Q_\\text{prediction}$ and $Q_\\text{target}$ depend on the same parameters $\\theta$ if only one network is used. This can lead to instability when regressing $Q_\\text{prediction}$ towards $Q_\\text{target}$ because the \"target is moving\". We ensure a \"fixed target\" by introducing a second network with fixed and only occasionally updated parameters that estimates the target $Q$-values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf1a5186",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- DQN has been observed to estimate unrealistically high $Q$-values. The reason for this is, that the Bellman equation *includes a maximization step over estimated action values, which tends to prefer overestimated to underestimated values* (see [van Hasselt et al. 2016, page 1](http://www.aaai.org/ocs/index.php/AAAI/AAAI16/paper/download/12389/11847)). \n",
    "\n",
    "- The estimated $Q$-values are noisy. Assume that the true $Q$-value is 0 for all actions. But because of the noisy estimation, some $Q$-values might be slightly positive, others slightly negative. The max operation in the Bellman equation will however always chose the small positive values, despite the fact, that those actions are not truly better. The estimatation of $Q$-values is thus biased towards larger values. How do we fix this?\n",
    "\n",
    "- Instead of estimating the $Q$-values in the next state $Q(s',a')$ with only the target network, we use the main network to estimate which action is the best and then ask the target network how high the $Q$-value is for that action. This way, the main network will still prefer the action with the small positive $Q$-value but because of the noisy estimation, the target network will predict a small positive **or** small negative $Q$-value for that action and on average, the predicted $Q$-values will be closer to 0.\n",
    "\n",
    "- Mathematically, the reason for the overestimation is, that the expectation of a maximum is greater than or equal to the maximum of an expectation [van Hasselt 2013, Theorem 1](https://arxiv.org/abs/1302.7175).\n",
    "\n",
    "- The Bellman equation changes from\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "Q_\\text{target}(s,a) &= r + \\gamma \\textrm{max} Q(s',a';\\theta_\\text{target}) &\\text{Normal DQN}\\\\\n",
    "\\text{to}\\qquad\\qquad Q_\\text{target}(s,a) &= r + \\gamma Q\\left(s',a'=\\text{argmax} Q(s',a';\\theta_\\text{main});\\theta_\\text{target}\\right)&\\text{Double DQN}\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87f15b8e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Code: http://localhost:8888/notebooks/8-7-reinforcement-learning/DQN.ipynb\n",
    "\n",
    "<table>\n",
    "  <tr>\n",
    "    <td><center><b>Breakout</b></center></td>\n",
    "     <td><center><b>Pong</b></center></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td><img src=\"./8-7-reinforcement-learning/GIF/ATARI_frame_0_reward_421.0.gif\" width=500 ></td>\n",
    "    <td><img src=\"./8-7-reinforcement-learning/GIF/ATARI_frame_0_reward_21.0.gif\" width=500 ></td>\n",
    "  </tr>\n",
    " </table>\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}