RL_part4.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pYs6LMEbNqoQ"
      },
      "source": [
        "# RL coursework, part IV (30 pts in total)\n",
        "\n",
        "---\n",
        "\n",
        "**Name:** Yuen Chung, CHAN\n",
        "\n",
        "**SN:**\n",
        "\n",
        "---\n",
        "\n",
        "**Due date:** *April 11th, 2024*\n",
        "\n",
        "---\n",
        "\n",
        "Standard UCL policy (including grade deductions) automatically applies for any late submissions.\n",
        "\n",
        "## How to submit\n",
        "\n",
        "When you have completed the exercises and everything has finished running, click on 'File' in the menu-bar and then 'Download .ipynb'. This file must be submitted to Moodle named as **`<studentnumber>_RL_part4.ipynb`** before the deadline above, where `<studentnumber>` is your student number."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rNuohp44N00i"
      },
      "source": [
        "### Objectives\n",
        "\n",
        "#### Q.1: You will implement a number of off-policy multi-step return estimates, and answer questions about their accuracy.\n",
        "\n",
        "#### Q.2: You will be looking at other, TD-like, updates to learn the value function. You will be asked to investigate different properties of these: e.g. convergence properties, variance of updates. This is akin to a typical analysis one would undertaken when proposing a new update rule to learn value functions.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z1p0fpbxQLyn"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "Ps5OnkPmDbMX"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "np.set_printoptions(precision=3, suppress=1)\n",
        "\n",
        "try:\n",
        "    plt.style.use('seaborn-notebook')\n",
        "except:\n",
        "    plt.style.use('seaborn-v0_8-notebook')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "thswfgXU_p05"
      },
      "source": [
        "## Q1 [11 points total]\n",
        "For many concrete algorithms, we need to combine multi-step updates with off-policy corrections.  The multi-step updates are necessary for efficient learning, while the off-policy corrections are necessary to learn about multiple things at once, or to correct for a distribution mismatch (e.g., when trying to perform a policy-gradient update from logged data).\n",
        "\n",
        "In this section, you will implement various different returns with off-policy corrections.  The next cell has two examples *without* corrections.  These examples compute equivalent returns, but compute those returns in different ways.  These are provided as reference implementations to help you.\n",
        "\n",
        "Note that the implementations both allow for immediate bootstrapping on the current state value. This is unconventional (most literature only allows the first bootstrapping to happen after the first step), but we will use this convention in all implementations below for consistency."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "KHNH35SZYHBu"
      },
      "outputs": [],
      "source": [
        "#@title On-policy return computations\n",
        "\n",
        "def on_policy(observations, actions, pi, mu, rewards, discounts,\n",
        "              trace_parameter, v_fn):\n",
        "  \"\"\"Compute on-policy return recursively.\"\"\"\n",
        "  del mu  # The policy probabilities are ignored by this function\n",
        "  del pi\n",
        "  T = len(rewards)  # number of transitions\n",
        "  r = rewards\n",
        "  d = discounts\n",
        "  l = trace_parameter\n",
        "  v = np.array([v_fn(o) for o in observations])\n",
        "  G = np.zeros((T,))\n",
        "  # recurse backwards to calculate returns\n",
        "  for t in reversed(range(T)):\n",
        "    # There are T+1 observations, but only T rewards, and the indexing here\n",
        "    # for the rewards is off by one compared to the indexing in the slides\n",
        "    # and in Sutton & Barto.  In other words, r[t] == R_{t+1}.\n",
        "    if t == T - 1:\n",
        "      G[t] = r[t] + d[t]*v[t + 1]\n",
        "    else:\n",
        "      G[t] = r[t] + d[t]*((1 - l)*v[t + 1] + l*G[t + 1])\n",
        "  v = v[:-1]  # Remove (T+1)th observation before calculating the returns\n",
        "  return (1 - l)*v + l*G\n",
        "\n",
        "\n",
        "def on_policy_error_recursion(observations, actions, pi, mu, rewards, discounts,\n",
        "                              trace_parameter, v_fn):\n",
        "  del pi  # The target policy probabilities are ignored by this function\n",
        "  del mu  # The behaviour policy probabilities are ignored by this function\n",
        "  T = len(rewards)  # number of transitions\n",
        "  r = rewards\n",
        "  d = discounts\n",
        "  l = trace_parameter\n",
        "  v = np.array([v_fn(o) for o in observations])\n",
        "  errors = np.zeros((T,))\n",
        "\n",
        "  error = 0.\n",
        "  # recurse backwards to calculate errors\n",
        "  for t in reversed(range(T)):\n",
        "    error = r[t] + d[t]*v[t + 1] - v[t] + d[t]*l*error\n",
        "    errors[t] = error\n",
        "  v = v[:-1]  # Remove (T+1)th observation before calculating the returns\n",
        "  return v + l*errors"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UNXhobrYHeiy"
      },
      "source": [
        "### Q 1.1 [5 points]\n",
        "Implement the return functions below and run the cells below that."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "cPzHHrmn5Tm7"
      },
      "outputs": [],
      "source": [
        "def full_importance_sampling(observations, actions, pi, mu, rewards, discounts, trace_parameter, v_fn):\n",
        "    \"\"\"\n",
        "    Compute off-policy return with full importance-sampling corrections, so that\n",
        "    the return G_t is corrected with the full importance-sampling correction of\n",
        "    the rest of the trajectory.\n",
        "    \"\"\"\n",
        "    # Shorten the variable names\n",
        "    T, r, d, l = len(rewards), rewards, discounts, trace_parameter\n",
        "\n",
        "    # Values\n",
        "    v = np.array([v_fn(o) for o in observations])\n",
        "    # Returns\n",
        "    G = np.zeros((T,))\n",
        "    # Importance-sampling correction\n",
        "    c = np.zeros((T,))\n",
        "\n",
        "    # Recurse backwards to calculate returns\n",
        "    for t in reversed(range(T)):\n",
        "        if t == T - 1:\n",
        "            G[t] = r[t] + d[t] * v[t+1]\n",
        "            c[t] = pi[t] / mu[t]  # Importance-sampling\n",
        "        else:\n",
        "            G[t] = r[t] + d[t] * ((1 - l)*v[t+1] + l*G[t+1])\n",
        "            c[t] = pi[t] / mu[t] * c[t+1]  # Importance-sampling\n",
        "\n",
        "    G *= c  # Apply correction\n",
        "    v = v[:-1]  # Remove (T+1)th observation\n",
        "\n",
        "    return (1 - l)*v + l*G\n",
        "\n",
        "\n",
        "def per_decision(observations, actions, pi, mu, rewards, discounts, trace_parameter, v_fn):\n",
        "    \"\"\"\n",
        "    Compute off-policy return with per-decision importance-sampling corrections.\n",
        "    \"\"\"\n",
        "    # Shorten the variable names\n",
        "    T, r, d, l = len(rewards), rewards, discounts, trace_parameter\n",
        "\n",
        "    # Values\n",
        "    v = np.array([v_fn(o) for o in observations])\n",
        "    # Returns\n",
        "    G = np.zeros((T,))\n",
        "\n",
        "    # Recurse backwards to calculate returns\n",
        "    for t in reversed(range(T)):\n",
        "        if t == T - 1:\n",
        "            G[t] = r[t] + d[t] * v[t+1]\n",
        "        else:\n",
        "            G[t] = r[t] + d[t] * ((1 - l)*v[t+1] + l*G[t+1])\n",
        "        rho_t = pi[t] / mu[t]\n",
        "        G[t] *= rho_t  # Importance-sampling correction\n",
        "\n",
        "    v = v[:-1]  # Remove (T+1)th observation\n",
        "\n",
        "    return (1 - l)*v + l*G\n",
        "\n",
        "\n",
        "def control_variates(observations, actions, pi, mu, rewards, discounts, trace_parameter, v_fn):\n",
        "    T, r, d, l = len(rewards), rewards, discounts, trace_parameter\n",
        "\n",
        "    # Values\n",
        "    v = np.array([v_fn(o) for o in observations])\n",
        "\n",
        "    errors = np.zeros((T+1,))\n",
        "\n",
        "    # Recurse backwards to calculate errors\n",
        "    for t in reversed(range(T)):\n",
        "        td_error = r[t] + d[t]*v[t+1] - v[t]\n",
        "        bt_error = d[t] * l * errors[t+1]\n",
        "        errors[t] = td_error + bt_error\n",
        "\n",
        "        rho_t = pi[t] / mu[t]\n",
        "        errors[t] *= rho_t\n",
        "\n",
        "    # Remove the (T+1)th term\n",
        "    v, errors = v[:-1], errors[:-1]\n",
        "\n",
        "    return v + l*errors\n",
        "\n",
        "\n",
        "def adaptive_bootstrapping(observations, actions, pi, mu, rewards, discounts, trace_parameter, v_fn):\n",
        "    T, r, d = len(rewards), rewards, discounts\n",
        "\n",
        "    # Values\n",
        "    v = np.array([v_fn(o) for o in observations])\n",
        "    # Adaptive trace parameter\n",
        "    l = np.zeros((T,))\n",
        "\n",
        "    errors = np.zeros((T+1,))\n",
        "\n",
        "    # Recurse backwards to calculate errors\n",
        "    for t in reversed(range(T)):\n",
        "        td_error = r[t] + d[t]*v[t+1] - v[t]\n",
        "        bt_error = d[t] * errors[t+1]\n",
        "        errors[t] = td_error + bt_error\n",
        "\n",
        "        rho_t = pi[t] / mu[t]\n",
        "        l[t] = min(1, 1/rho_t)\n",
        "        errors[t] *= rho_t\n",
        "        errors[t] *= l[t]\n",
        "\n",
        "    # Remove the (T+1)th term\n",
        "    v, errors = v[:-1], errors[:-1]\n",
        "\n",
        "    return v + errors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "7EEHYK89ANIA"
      },
      "outputs": [],
      "source": [
        "#@title (Run, don't modify) Functions to generate experience, compute values\n",
        "MU_RIGHT = 0.5\n",
        "PI_RIGHT = 0.9\n",
        "NUMBER_OF_STEPS = 5\n",
        "DISCOUNT = 0.99\n",
        "\n",
        "def generate_experience():\n",
        "  r\"\"\"Generate experience trajectories from a tabular tree MDP.\n",
        "\n",
        "  This function will start in state 0, and will then generate actions according\n",
        "  to a uniformly random behaviour policy.  When A_t == 0, the action will be to\n",
        "  the left, with A_t==1, it will be to the right.  The states are nunmbered as\n",
        "  depicted below:\n",
        "          0\n",
        "         / \\\n",
        "        1   2\n",
        "       / \\ / \\\n",
        "      3   4   5\n",
        "         ...\n",
        "\n",
        "  Args:\n",
        "      number_of_steps: the number of total steps.\n",
        "      p_right: probability of the behaviour to go right.\n",
        "\n",
        "  Returns:\n",
        "      A dictionary with elements:\n",
        "        * observations (number_of_steps + 1 integers): the\n",
        "          observations are just the actual (integer) states\n",
        "        * actions (number_of_steps integers): actions per step\n",
        "        * rewards (number_of_steps scalars): rewards per step\n",
        "        * discounts (number_of_steps scalars): currently always 0.9,\n",
        "          except the last one which is zero\n",
        "        * mu (number_of_steps scalars): probability of selecting each\n",
        "          action according to the behavious policy\n",
        "        * pi (number_of_steps scalars): probability of selecting each\n",
        "          action according to the target policy (here p(1) = 0.9 and\n",
        "          p(0) = 0.1, where a==1 implies we go 'right')\n",
        "  \"\"\"\n",
        "  # generate actions\n",
        "  actions = np.array(np.random.random(NUMBER_OF_STEPS,) < MU_RIGHT,\n",
        "                     dtype=int)\n",
        "  s = 0\n",
        "  # compute resulting states\n",
        "  states = np.cumsum(np.arange(1, NUMBER_OF_STEPS + 1) + actions)\n",
        "  states = np.array([0] + list(states))  # add start state\n",
        "\n",
        "  # in this case, observations are just the real states\n",
        "  observations = states\n",
        "\n",
        "  # generate rewards\n",
        "  rewards     = 2.*actions - 1. # -1 for left, +1 for right,\n",
        "  rewards[-1] = np.sum(actions)  # extra final reward for going right\n",
        "\n",
        "  # compute discounts\n",
        "  discounts     = DISCOUNT * np.ones_like(rewards)\n",
        "  discounts[-1] = 0.  # final transition is terminal, has discount=0\n",
        "\n",
        "  # determine target and behaviour probabilities for the selected actions\n",
        "  pi = np.array([1. - PI_RIGHT, PI_RIGHT])[actions] # Target probabilities\n",
        "  mu = np.array([1. - MU_RIGHT, MU_RIGHT])[actions] # Behaviour probabilities\n",
        "\n",
        "  return dict(observations=observations,\n",
        "              actions=actions,\n",
        "              pi=pi,\n",
        "              mu=mu,\n",
        "              rewards=rewards,\n",
        "              discounts=discounts)\n",
        "\n",
        "def true_v(s, pi, number_of_steps):\n",
        "  \"\"\"Compute true state value recursively.\"\"\"\n",
        "  depth = int(np.floor((np.sqrt(1 + 8*s) - 1)/2))\n",
        "  position = int(s - depth*(depth+1)/2)\n",
        "  remaining_steps = number_of_steps - depth\n",
        "  final_reward = DISCOUNT**(remaining_steps-1)*(position + pi*remaining_steps)\n",
        "  reward_per_step = pi*(+1) + (1 - pi)*(-1)\n",
        "  discounted_steps = (1 - DISCOUNT**(remaining_steps - 1))/(1 - DISCOUNT)\n",
        "  reward_along_the_way = reward_per_step * discounted_steps\n",
        "  return reward_along_the_way + final_reward\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "CCFMUmOfRTqZ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 20.016 442.125 149.121   6.213   0.871]\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x800 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Run experiment (don't modify)\n",
        "algs = ['on_policy', 'full_importance_sampling', 'per_decision', 'control_variates', 'adaptive_bootstrapping']\n",
        "\n",
        "# Precompute state values (for efficiency)\n",
        "N = NUMBER_OF_STEPS\n",
        "true_vs = [true_v(s, PI_RIGHT, N) for s in range((N+1)*(N+2)//2)]\n",
        "\n",
        "def random_v(iteration, s):\n",
        "  rng = np.random.RandomState(seed=s + iteration*10000)\n",
        "  return true_vs[s] + rng.normal(loc=0, scale=1.)  # Add fixed random noise\n",
        "\n",
        "def plot_errors(ax, errors):\n",
        "  errors = np.array(errors)\n",
        "  ax.violinplot(np.log10(errors), showextrema=False)\n",
        "  ax.plot(range(1, len(algs)+1), np.log10(errors).T,\n",
        "          '.', color='#667799', ms=7, alpha=0.2)\n",
        "  ax.plot(range(1, len(algs)+1), np.log10(np.mean(errors, axis=0)),\n",
        "          '.', color='#000000', ms=20)\n",
        "  ax.set_yticks(np.arange(-2, 5))\n",
        "  ax.set_yticklabels(10.**np.arange(-2, 5), fontsize=13)\n",
        "  ax.set_ylabel(\"Value error $(v(s_0) - v_{\\\\pi}(s_0))^2$\", fontsize=15)\n",
        "  ax.set_xticks(range(1, len(algs)+1))\n",
        "  ax.set_xticklabels(algs, fontsize=15, rotation=70)\n",
        "  ax.set_ylim(-1, 4)\n",
        "\n",
        "fig = plt.figure(figsize=(12, 8))\n",
        "\n",
        "errors = []\n",
        "estimates = []\n",
        "v0 = true_vs[0]\n",
        "for iteration in range(1000):\n",
        "  errors.append([])\n",
        "  estimates.append([])\n",
        "  trajectory = generate_experience()\n",
        "  for alg in algs:\n",
        "    estimate = eval(alg)(**trajectory,\n",
        "                        v_fn=lambda s: random_v(iteration, s),\n",
        "                        trace_parameter=0.9)\n",
        "    errors[-1].append((estimate[0] - v0)**2)\n",
        "print(np.mean(errors, axis=0))\n",
        "plot_errors(plt.gca(), errors)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7hlc4jctHHqv"
      },
      "source": [
        "Above, the distributions of mean squared value errors are shown, with the mean as a big black dot and the (1,000) individual return samples as small black dots.\n",
        "\n",
        "### Q 1.2 [3 points]\n",
        "Explain the ranking in terms of value error of the different return estimates.\n",
        "\n",
        "> The ranking of mean squared error in a order of increasing performance:\n",
        ">\n",
        "> - **Full Importance Sampling**\n",
        "> \n",
        ">   This approach suffers from extremely high variance when the behavior policy is very different from the target policy. Such extreme differences would affect whole trajectories as corrections are applied fully. The high variance translates to large MSE in value estimates and thus performs the worst.\n",
        "> \n",
        "> - **Per-decision Importance Sampling**\n",
        "> \n",
        ">   This approach attempts to reduce the variance of full importance sampling by applying corrections at each step rather than over whole trajectories. By breaking down the correction, it reduces the variance. Its performance is generally better than full importance sampling because the variance is lower, which explains its higher rank.\n",
        "> \n",
        "> - **On Policy**\n",
        "> \n",
        ">   On-policy learning have lower variance as it does not perform reweighing as the previous two approaches. Also, it behaves using the same policy as the data is generated. However, it might not explore the environment thorough enough since it only focus on data generated by the target policy.\n",
        "> \n",
        "> - **Per-decision Importance Sampling with Control Variates**\n",
        "> \n",
        ">   This approach builds on per-decision importance sampling by incorporating control variates to further suppress the variance. As the high variance of per-decision importance sampling mainly comes from extreme values of the importance sampling ratio $\\rho_t$, an additional term $(1-\\rho_t)v_t(S_t)$ is added to control the variance. The introduction of the 'control variate' term leads to the improvement in performance in terms of MSE by reducing the variance. \n",
        "> \n",
        "> - **Per-decision Importance Sampling with Control Variates and Adaptive Bootstrapping**\n",
        "> \n",
        ">   To additionally reduce variance, the adaptive bootstrapping strategy performs bootstrapping only when $\\rho_t > 1$. Hence, the sum of errors is truncated when the behavior policy happens to be less likely than the target policy. It prevents being way too \"off-policy\". Its best performance results from the cumulative benefits of per-decision importance sampling, control variates and adat"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O0Uk1d9b4CPc"
      },
      "source": [
        "\n",
        "\n",
        "### Q 1.3 [3 points]\n",
        "Could there be a reason to **not** choose the best return according to this ranking when learning off-policy?  Explain your answer.\n",
        "\n",
        "> The best return is corrected using per-decision importance sampling with control variates and adaptive bootstrapping.\n",
        "> \n",
        "> There are a few reasons not to choose this correction:\n",
        ">\n",
        "> - When bootstrapping have to be reduced significantly\n",
        ">\n",
        ">   As shown in lectures, bootstrapping too much might lead to divergence when using function approximation. For the function approximation to converge, other approach have to be adopted.\n",
        ">\n",
        "> - When the environment is simple and with short trajectories\n",
        ">\n",
        ">   In this case, the benefit of the approach using control variate and adaptive bootstrapping might not be necessary. Simpler methos with less computations might show comparable results.\n",
        ">\n",
        "> - When importance sampling is not necessary\n",
        ">\n",
        ">   When the behavior policy is similar to the target policy, the importance scaling might not be necessary. Simpler methods might out-perform without the added complexity."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u5Xn8bDNFm-H"
      },
      "source": [
        "## Q2 [19 points total]\n",
        " Consider a MDP $M = (\\mathcal{S}, \\mathcal{A}, p, r, \\gamma)$ and a behaviour policy $\\mu$. We use policy $\\mu$ to generate trajectories of experience:\n",
        "\\begin{equation*}\n",
        "    (s_{t}, a_{t}, r_{t},s_{t+1}, a_{t+1}, r_{t+1},\\cdots, s_{t+n-1}, a_{t+n-1}, r_{t+n-1}, s_{t+n}, a_{t+n}) \\,.\n",
        "\\end{equation*}\n",
        "Note that this is an $n$-step sequence, starting from time $t$.\n",
        "\n",
        "Given these partial trajectories we consider the following learning problems:\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vc8FfT06lYY"
      },
      "source": [
        "### Q2.1 [9 points]\n",
        "Consider a learning update based on the following temporal difference error:\n",
        "$$\\delta_t = R(S_t, A_t) + \\gamma R(S_{t+1}, A_{t+1}) + \\gamma^2 \\max_a q(S_{t+2}, a) - q(S_t, A_t)$$\n",
        "\n",
        "Consider updating a tabular action value function with TD.\n",
        "\n",
        "i) Does the resulting value function converge, under any initialisation of the value function? Consider an appropiate learning rate (Robbins–Monro conditions). If so, prove the convergence under infinity number of interactions with this MDP, under fixed behaviour policy $\\mu$ and show its convergence point. If not, show why it diverges. (7 points)\n",
        "\n",
        "ii) Under which conditions, would the above process converge to the optimal value function $q_*$ ? (2 points)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3H4p8jZj6bGP"
      },
      "source": [
        "#### **[Answer]**\n",
        "\n",
        "The TD error shown can be consider as a 2-step return Q learning. We will show that updating a tabular action value function $q_t$ with the given TD error using\n",
        "$$\n",
        "q_{t+1}(S_t, A_t) = q_t(S_t, A_t) + \\alpha_t(S_t, A_t) \\left[\n",
        "        R(S_t, A_t) + \\gamma R(S_{t+1}, A_{t+1})\n",
        "        + \\gamma^2 \\max_a q(S_{t+2}, a)\n",
        "        - q_t(S_t, A_t)\n",
        "    \\right] \\quad\n",
        "$$\n",
        "converges to the optimal $q^*$ if\n",
        "\n",
        "- The state space $\\mathcal{S}$ and action space $\\mathcal{A}$ are both finite.\n",
        "- The Robbins-Monro conditions on $\\alpha_t(s, a)$ is satisfied $\\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$, i.e.\n",
        "    $$\\sum_t \\alpha_t(s, a) = \\infty \\quad \\text{and} \\quad \\sum_t \\alpha_t^2(s, a) < \\infty \\quad.$$\n",
        "- $\\mu(a|s) > 0  \\space \\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$\n",
        "- $R(s, a)$ is finite $\\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$.\n",
        "- The action value initialisation $q_0(s, a)$ is finite $\\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$.\n",
        "\n",
        "##### **Proof**\n",
        "\n",
        "The proof is inspired by the convergence proof of Q-Learning in the following two references:\n",
        "1. [T. Jaakkola, M. I. Jordan and S. P. Singh, \"On the Convergence of Stochastic Iterative Dynamic Programming Algorithms,\" in Neural Computation, vol. 6, no. 6, pp. 1185-1201, Nov. 1994, doi: 10.1162/neco.1994.6.6.1185.](https://ieeexplore.ieee.org/abstract/document/6796861)\n",
        "2. [Francisco S. Melo, \"Convergence of Q-Learning: A Simple Proof\", Institute for Systems and Robotics, Instituto Superior Técnico, Lisboa, Portugal.](http://users.isr.ist.utl.pt/~mtjspaan/readingGroup/ProofQlearning.pdf)\n",
        "\n",
        "Firstly, we need the following theorem from stochastic approximation, the proof of which is provided in [1].\n",
        "\n",
        "> **Theorem 1**\n",
        "> A random iterative process $\\Delta_{t+1}(x) = (1 - \\alpha_t(x))\\Delta_t(x) + \\alpha_t(x)F_t(x)$ converges to zero with probability 1 under the following assumptions: \n",
        "> 1. The state space $\\mathcal{X}$ of state $x$ is finite. \n",
        "> 2. $\\sum_t \\alpha_t(x) = \\infty, \\sum_t \\alpha_t^2(x) < \\infty$ uniformly with probability 1 $\\forall x \\in \\mathcal{X}$.\n",
        "> 3. Each state is visited infinitely often.\n",
        "> 4. $\\|\\mathbf{E}[F_t(x)|P_t]\\|_\\infty \\leq \\kappa \\| \\Delta_t \\|_\\infty$, where $\\kappa \\in (0, 1)$.\n",
        "> 5. $\\mathrm{Var}[F_t(x)|P_t] \\leq C(1+\\|\\Delta_t\\|_\\infty)^2$, where $C$ is some constant.\n",
        "> \n",
        "> Here $P_t$ stands for the trajectories up to (including) time step $t$.\n",
        "\n",
        "Note that the theorem is slightly modified from that in [1] as the original theorem is more powerful than we need in this proof.\n",
        "\n",
        "The proof of convergence now follows by relating our learning algorithm to the stochastic process defined by Theorem 1.\n",
        "\n",
        "The update on $q$ according to the given TD error can be written as\n",
        "$$\n",
        "q_{t+1}(S_t, A_t) = (1 - \\alpha_t) q_t(S_t, A_t) + \\alpha_t \\left[\n",
        "        R(S_t, A_t) + \\gamma R(S_{t+1}, A_{t+1})\n",
        "        + \\gamma^2 \\max_a q(S_{t+2}, a)\n",
        "    \\right] \\quad.\n",
        "$$\n",
        "Subtracting the optimal Q-function $q^*(S_t, A_t)$ from both sides yields\n",
        "$$\n",
        "\\Delta_{t+1}(S_t, A_t) = (1 - \\alpha_t) \\Delta_t(S_t, A_t) + \\alpha_t \\left[\n",
        "        R(S_t, A_t) + \\gamma R(S_{t+1}, A_{t+1})\n",
        "        + \\gamma^2 \\max_a q(S_{t+2}, a)\n",
        "        - q^*(S_t, A_t)\n",
        "    \\right] \\quad ,\n",
        "$$\n",
        "where $\\Delta_t(\\cdot) = q_t(\\cdot) - q^*(\\cdot)$.\n",
        "\n",
        "To use Theorem 1, we define\n",
        "$$\n",
        "F_t(S_t, A_t) = R(S_t, A_t) + \\gamma R(s', a')\n",
        "        + \\gamma^2 \\max_{a''} q_t(s'', a'')\n",
        "        - q^*(S_t, A_t)\n",
        "    \\quad .\n",
        "$$\n",
        "\n",
        "At this point, each $(s, a)$ pair correspond to a state $x$ in Theorem 1. To fulfill condition 3 in Theorem 1, the behavior policy must satisfy\n",
        "$$\n",
        "\\mu(a | s) > 0 \\qquad \\forall s \\in \\mathcal{S}, a \\in \\mathcal{A}\n",
        "$$\n",
        "\n",
        "For $\\Delta_t$ to converge to zero (i.e. $q_t \\rightarrow q^*$), we have to show that $F_t(S_t, A_t)$ have the required properties on its expected value and variance.\n",
        "\n",
        "- The max norm of the expected value of $F_t$ is bounded\n",
        "    $$\n",
        "    \\begin{align*}\n",
        "    \\mathbb{E}[F_t(S_t, A_t) | P_t]    \n",
        "    & = \\mathbb{E}_{s', a', s''} \\left[\n",
        "            R(S_t, A_t) + \\gamma R(s', a')\n",
        "            + \\gamma^2 \\max_{a''} q_t(s'', a'')\n",
        "            - q^*(S_t, A_t)\n",
        "        \\right]  \\\\\n",
        "    & = R(S_t, A_t) + \n",
        "        \\mathbb{E}_{s', a', s''} \\left[\n",
        "            \\gamma R(s', a')\n",
        "            + \\gamma^2 \\max_{a''} q_t(s'', a'')\n",
        "        \\right]\n",
        "        - q^*(S_t, A_t) \\\\\n",
        "    & = R(S_t, A_t) \n",
        "        + \\gamma \\sum_{s', a'} p(s'|S_t, A_t) \\mu(a'|s')\\left[\n",
        "            R(s', a') + \\gamma \\sum_{s''} p(s''|s', a') \\max_{a''}q_t(s'', a'')\n",
        "        \\right]  \n",
        "        - q^*(S_t, A_t) \\\\\n",
        "    & = R(S_t, A_t) \n",
        "        + \\gamma \\sum_{s', a'} p(s'|S_t, A_t) \\mu(a'|s') (\\mathcal{T_Q^* }q_t)(s', a')\n",
        "        - q^*(S_t, A_t) \\\\\n",
        "    & \\leq R(S_t, A_t) \n",
        "        + \\gamma \\sum_{s'} p(s'|S_t, A_t) \\max_{a'} (\\mathcal{T_Q^*}q_t)(s', a')\n",
        "        - q^*(S_t, A_t) \\\\\n",
        "    & = (\\mathcal{T_Q^*}(\\mathcal{T_Q^*}q_t))(S_t, A_t)\n",
        "        - q^*(S_t, A_t) \\\\\n",
        "    \\end{align*}\n",
        "    $$\n",
        "    where $\\mathcal{T_Q^*}$ is the Bellman Optimality Operator defined as\n",
        "    $$\n",
        "    (\\mathcal{T_Q^*}f)(s, a) = r(s, a) + \\gamma \\sum_{s'} p(s'|s, a) \\max_{a'} f(s', a')  \\qquad \\forall f \\in \\mathcal{Q}: \\mathcal{S} \\times \\mathcal {A} \\rightarrow \\mathbb{R}\n",
        "    \\quad .\n",
        "    $$\n",
        "    Next, we utilise the properties of the operator.\n",
        "    $$\n",
        "    \\begin{align*}\n",
        "    ||\\mathbb{E}[F_t | P_t]||_\\infty \n",
        "    & \\leq || \\mathcal{T_Q^*}(\\mathcal{T_Q^*}q_t) - q^* ||_\\infty \\\\\n",
        "    & = || \\mathcal{T_Q^*}(\\mathcal{T_Q^*}q_t) - \\mathcal{T_Q^*}q^* ||_\\infty && (q^* \\text{ is a fixed point of } \\mathcal{T_Q^*}) \\\\\n",
        "    & \\leq \\gamma || \\mathcal{T_Q^*}q_t - q^* ||_\\infty && (\\mathcal{T_Q^*} \\text{ is } \\gamma\\text{-contraction w.r.t } ||\\cdot||_\\infty) \\\\\n",
        "    & = \\gamma || \\mathcal{T_Q^*}q_t - \\mathcal{T_Q^*}q^* ||_\\infty && (q^* \\text{ is a fixed point of } \\mathcal{T_Q^*}) \\\\\n",
        "    & \\leq \\gamma^2 || q_t - q^* ||_\\infty && (\\mathcal{T_Q^*} \\text{ is } \\gamma\\text{-contraction w.r.t } ||\\cdot||_\\infty) \\\\\n",
        "    & = \\gamma^2 || \\Delta_t||_\\infty\n",
        "    \\end{align*}\n",
        "    $$\n",
        "    Hence, the criterion on the expected value is satisfied without further assumption.\n",
        "\n",
        "- The variance of $F_t$ is bounded\n",
        "\n",
        "    The variance is given by\n",
        "    $$\n",
        "    \\begin{align*}\n",
        "    \\text{Var}[F_t(S_t, A_t)|P_t]\n",
        "    & = \\text{Var}\\left[\n",
        "            R(S_t, A_t) + \\gamma R(s', a')\n",
        "            + \\gamma^2 \\max_{a''} q_t(s'', a'')\n",
        "            - q^*(S_t, A_t)\n",
        "            \\Big| P_t\n",
        "        \\right] \\\\\n",
        "    \\end{align*}\n",
        "    $$\n",
        "    Note that $q^*(S_t, A_t)$ is deterministic as $(S_t, A_t)$ is contained in $P_t$. We have $\\text{Var}[q^*(S_t, A_t)]=0$ and obtain\n",
        "    $$\n",
        "    \\begin{align*}\n",
        "    \\text{Var}[F_t(S_t, A_t)|P_t]\n",
        "    & = \\text{Var}\\left[\n",
        "            R(S_t, A_t) + \\gamma R(s', a')\n",
        "            + \\gamma^2 \\max_{a''} q_t(s'', a'')\n",
        "            \\Big| P_t\n",
        "        \\right] \\\\\n",
        "    \\end{align*}\n",
        "    $$\n",
        "    As long as $R(s, a)$ and $q_t(s, a)$ is finite for all pairs of $(s, a)$, it is trivial that\n",
        "    $$\n",
        "    \\text{Var}[F_t(S_t, A_t)|P_t] \\leq C(1 + ||\\Delta_t||_\\infty)^2\n",
        "    $$\n",
        "    for some $C$. It follows that $q_t(s, a)$ is finite if its initialisation and $R(s, a)$ are finite.\n",
        "\n",
        "Therefore, the proof for conditions on convergence is concluded."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IfIqVjrP6QI-"
      },
      "source": [
        "### Q2.2 [10 points]\n",
        "\n",
        "Consider the same questions now for the following temporal difference error\n",
        "\\begin{equation}\n",
        "        \\delta_t = r(S_{t},A_{t}) + \\gamma \\frac{\\pi(A_{t+1}|S_{t+1})}{\\mu(A_{t+1}|S_{t+1})} \\left[ r(S_{t+1},A_{t+1}) + \\gamma \\max_{a} q(S_{t+2},a) \\right] - q(S_t, A_t)\n",
        "\\end{equation}\n",
        "\n",
        "where $\\pi(a|s) \\in \\arg\\max_a q(s,a), \\forall s,a \\in \\mathcal{A} \\times \\mathcal{S}$ and consider the behaviour policy to be either:\n",
        "\n",
        "  a. $\\mu(a|s) \\in \\arg\\max_a q(s,a), \\forall s,a \\in \\mathcal{A} \\times \\mathcal{S}$,\n",
        "  \n",
        "  b. $\\mu(a|s) = \\frac{1}{|\\mathcal{A}|}$ (uniformly random policy).\n",
        "\n",
        "Answer the below two questions for **both choices** of the behaviour policy $\\mu$:\n",
        "* i)  Does updating a tabular action value function with this TD error converge to the optimal value function $q_*$? Consider an appropiate learning rate (Robbins–Monro conditions). If so, prove this convergence under infinity number of interaction with this MDP, under behaviour policy $\\mu$. If not, show why it diverges or alternatively convergence to a different solution. (4 points)\n",
        "* ii) How does the variance of this update compare to the one induced by the error in Q5.1? (3 points).\n",
        "* iii) Can you propose a different behaviour policy that achieves a lower variance than any of the choices we considered for $\\mu$? Prove that your behaviour policy achieve this. Argue why, if that is not possible. (3 points)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NGqQJRzD6Tww"
      },
      "source": [
        "#### **[Answer]**\n",
        "\n",
        "##### **(i) - Convergence**\n",
        "\n",
        "- **a.** $\\mu(a|s) \\in \\arg\\max_a q(s,a) \\quad \\forall s,a \\in \\mathcal{A} \\times \\mathcal{S}$\n",
        "  \n",
        "    To keep the correction factor $\\pi(a|s)/\\mu(a|s)$ finite, $\\mu(s, a)$ has to be non-zero for all $(s, a) \\in \\mathcal{S} \\times \\mathcal{A}$.\n",
        "    Hence, we have\n",
        "    $$ \n",
        "    \\mu(a | s) > 0 \\qquad \\forall s \\in \\mathcal{S}, a \\in \\mathcal{A}\n",
        "    $$\n",
        "    due to the nature of probability. Also, the correction factor reduces to 1 as the target policy and behavior policy are the same.\n",
        "\n",
        "    The conditions of convergence and its proof follow from that in Q2.1 as the TD error and update rule are the same.\n",
        "\n",
        "- **b.** $\\mu(a|s) = 1/|\\mathcal{A}|$\n",
        "\n",
        "    The proof of convergence and conditions basically follows the same thought in Q2.1, where $F_t(S_t, A_t)$ becomes\n",
        "    $$\n",
        "    F_t(S_t, A_t) = R(S_t, A_t) + \\frac{\\pi(a'|s')}{\\mu(a'|s')}[\n",
        "                \\gamma R(s', a')\n",
        "                + \\gamma^2 \\max_{a''} q_t(s'', a'')\n",
        "            ]\n",
        "            - q^*(S_t, A_t)\n",
        "        \\quad .\n",
        "    $$\n",
        "    We would verify the required properties on its expected value and variance.\n",
        "    - The max norm of the expected value of $F_t$ is bounded\n",
        "        $$\n",
        "        \\begin{align*}\n",
        "        \\mathbb{E}[F_t(S_t, A_t) | P_t]    \n",
        "        & = \\mathbb{E}_{s', a', s''} \\left[\n",
        "                R(S_t, A_t) + \\frac{\\pi(a'|s')}{\\mu(a'|s')} [\\gamma R(s', a')\n",
        "                + \\gamma^2 \\max_{a''} q_t(s'', a'')]\n",
        "                - q^*(S_t, A_t)\n",
        "            \\right]  \\\\\n",
        "        & = R(S_t, A_t) + \n",
        "            \\gamma \\mathbb{E}_{s', a', s''} \\left[ \\frac{\\pi(a'|s')}{\\mu(a'|s')} [\n",
        "                R(s', a')\n",
        "                + \\gamma \\max_{a''} q_t(s'', a'')]\n",
        "            \\right]\n",
        "            - q^*(S_t, A_t) \\\\\n",
        "        & = R(S_t, A_t) \n",
        "            +  \\gamma \\sum_{s', a'} p(s'|S_t, A_t) \\mu(a'|s')\n",
        "                \\frac{\\pi(a'|s')}{\\mu(a'|s')} \\left[\n",
        "                R(s', a') + \\gamma \\sum_{s''} p(s''|s', a') \\max_{a''}q_t(s'', a'')\n",
        "            \\right]  \n",
        "            - q^*(S_t, A_t) \\\\\n",
        "        & = R(S_t, A_t) \n",
        "            +  \\gamma \\sum_{s', a'} p(s'|S_t, A_t) \\pi(a'|s') \\left[\n",
        "                R(s', a') + \\gamma \\sum_{s''} p(s''|s', a') \\max_{a''}q_t(s'', a'')\n",
        "            \\right]  \n",
        "            - q^*(S_t, A_t) \\\\\n",
        "        & = R(S_t, A_t) \n",
        "            + \\gamma \\sum_{s', a'} p(s'|S_t, A_t) \\pi(a'|s') (\\mathcal{T_Q^* }q_t)(s', a')\n",
        "            - q^*(S_t, A_t) \\\\\n",
        "\n",
        "        & \\leq R(S_t, A_t) \n",
        "            + \\gamma\\sum_{s'} p(s'|S_t, A_t) \\max_{a'} (\\mathcal{T_Q^*}q_t)(s', a')\n",
        "            - q^*(S_t, A_t) \\\\\n",
        "        & = (\\mathcal{T_Q^*}(\\mathcal{T_Q^*}q_t))(S_t, A_t)\n",
        "            - q^*(S_t, A_t) \\\\\n",
        "        \\end{align*}\n",
        "        $$\n",
        "        The remaining part is the same as that in Q2.1 without any further assumption.\n",
        "\n",
        "    - The variance of $F_t$ is bounded\n",
        "        The variance is given by\n",
        "        $$\n",
        "        \\begin{align*}\n",
        "        \\text{Var}[F_t(S_t, A_t)|P_t]\n",
        "        & = \\text{Var}\\left[\n",
        "                R(S_t, A_t) + |\\mathcal{A}|\\pi(a'|s') [\\gamma R(s', a')\n",
        "                + \\gamma^2 \\max_{a''} q_t(s'', a'')]\n",
        "                - q^*(S_t, A_t)\n",
        "                \\Big| P_t\n",
        "            \\right] \\\\\n",
        "        \\end{align*}\n",
        "        $$\n",
        "        Note that $q^*(S_t, A_t)$ is deterministic as $(S_t, A_t)$ is contained in $P_t$. We have $\\text{Var}[q^*(S_t, A_t)]=0$ and obtain\n",
        "        $$\n",
        "        \\begin{align*}\n",
        "        \\text{Var}[F_t(S_t, A_t)|P_t]\n",
        "        & = \\text{Var}\\left[\n",
        "                R(S_t, A_t) + |\\mathcal{A}|\\pi(a'|s') [\\gamma R(s', a')\n",
        "                + \\gamma^2 \\max_{a''} q_t(s'', a'')]\n",
        "                \\Big| P_t\n",
        "            \\right] \\\\\n",
        "        \\end{align*}\n",
        "        $$\n",
        "        Given that $\\pi(a'|s') \\in [0, 1]$ due to the nature of probability. As long as $R(s, a)$ and $q_t(s, a)$ is finite for all pairs of $(s, a)$, it is trivial that\n",
        "        $$\n",
        "        \\text{Var}[F_t(S_t, A_t)|P_t] \\leq C(1 + ||\\Delta_t||_\\infty)^2\n",
        "        $$\n",
        "        for some $C$. It follows that $q_t(s, a)$ is finite if its initialisation and $R(s, a)$ are finite.\n",
        "\n",
        "    To conclude, the update rule using this TD error converges to the optimal $q^*$ if\n",
        "    - The state space $\\mathcal{S}$ and action space $\\mathcal{A}$ are both finite.\n",
        "    - The Robbins-Monro conditions on $\\alpha_t(s, a)$ is satisfied $\\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$, i.e.\n",
        "        $$\\sum_t \\alpha_t(s, a) = \\infty \\quad \\text{and} \\quad \\sum_t \\alpha_t^2(s, a) < \\infty \\quad.$$\n",
        "    - $\\mu(a|s) > 0 \\space \\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$\n",
        "    - $R(s, a)$ is finite $\\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$.\n",
        "    - The action value initialisation $q_0(s, a)$ is finite $\\forall (s, a) \\in \\mathcal{S} \\times \\mathcal{A}$.\n",
        "    \n",
        "##### **(ii) - Variance comparison with Q2.1**\n",
        "\n",
        "- **a.** $\\mu(a|s) \\in \\arg\\max_a q(s,a) \\quad \\forall s,a \\in \\mathcal{A} \\times \\mathcal{S}$\n",
        "  \n",
        "  As the update rule is same as Q2.1, the variance is also the same.\n",
        "\n",
        "- **b.** $\\mu(a|s) = 1/|\\mathcal{A}|$\n",
        "\n",
        "    To compare the variance of the two different errors, we denote the update in Q2.1 as\n",
        "    $$\n",
        "    \\delta_t^{(1)} = r(S_t, A_t) + \\gamma r(S_{t+1}, A_{t+1}) \n",
        "    + \\gamma^2 \\max_a q_t(S_{t+2}, a) - q_t(S_t, A_t)\n",
        "    $$\n",
        "    and the update in Q2.2b (this part) as\n",
        "    $$\n",
        "    \\delta_t^{(2)} = r(S_t, A_t) + \\frac{\\pi(A_t+1|S_{t+1})}{\\mu(A_t+1|S_{t+1})} [\\gamma r(S_{t+1}, A_{t+1}) \n",
        "    + \\gamma^2 \\max_a q_t(S_{t+2}, a)] - q_t(S_t, A_t) \\quad.\n",
        "    $$\n",
        "    In case of ***off-policy*** update according to the behaviour policy $\\mu(a|s)$, the expectations of $\\delta_t^{(1)}$ and $\\delta_t^{(2)}$ are given by\n",
        "    $$\n",
        "    \\begin{align*}\n",
        "    \\mathbb{E}_\\mu[\\delta_t^{(1)} | P_t]\n",
        "    & = r(S_t, A_t) - q_t(S_t, A_t) + \\gamma \\sum_{s'} p(s'|S_t, A_t) \\sum_{a'}\\mu(a'|s') \\mathbb{E}_{s''|s'}[G_{t+1}(s', a')] \\\\\n",
        "\n",
        "    \\mathbb{E}_\\mu[\\delta_t^{(2)} | P_t]\n",
        "    & = r(S_t, A_t) - q_t(S_t, A_t) + \\gamma \\sum_{s'} p(s'|S_t, A_t) \\sum_{a'}\\pi(a'|s') \\mathbb{E}_{s''|s'}[G_{t+1}(s', a')]\n",
        "    \\end{align*}\n",
        "    $$\n",
        "    where\n",
        "    $$\n",
        "    G_{t+1}(s', a') = r(s', a') + \\gamma \\max_{a''} q_t(s'', a'')\n",
        "    $$\n",
        "    It is observed that the two expectations are different only in the policy of sampling action $a'$ at state $s'$. In general, no strict comparison of these two expectations values can be performed as it depends on the Markov process, which applies to the variance as well.\n",
        "\n",
        "    On the other hand, by inspecting the expression of $\\mathbb{E}_\\mu[\\delta_t^{(2)}|P_t]$, one can notice that it is exactly the same as $\\mathbb{E}_\\pi[\\delta_t^{(1)}|P_t]$, i.e. the expectation value of the ***on-policy*** update using the error in Q2.1.\n",
        "\n",
        "    Hence, one can compare the variance of on-policy update using $\\delta_t^{(1)}$ and the off-policy update using $\\delta_t^{(2)}$. In particular, we can focus on comparing the variance of terms\n",
        "    $$\n",
        "    G_{t+1}(S_{t+1}, A_{t+1})\n",
        "    \\quad \\text{and} \\quad \n",
        "    \\frac{\\pi(a'|s')}{\\mu(a'|s')}G_{t+1}(S_{t+1}, A_{t+1})\n",
        "    \\quad ,\n",
        "    $$\n",
        "    where the two updates differ from each other. Using the fact that these terms have the same mean, we obtain\n",
        "    $$\n",
        "    \\begin{align*}\n",
        "    & \\mathrm{Var}_\\mu[\\frac{\\pi(a'|s')}{\\mu(a'|s')}G_{t+1}(S_{t+1}, A_{t+1})|P_t] - \\mathrm{Var}_\\pi[{\\mu(a'|s')}G_{t+1}(S_{t+1}, A_{t+1})|P_t] \\\\\n",
        "    & = \\mathbb{E}_\\mu[\\left( \\frac{\\pi(a'|s')}{\\mu(a'|s')} G_{t+1}(S_{t+1}, A_{t+1}) \\right)^2 | P_t] \n",
        "        - \\mathbb{E}_\\pi[\\left( G_{t+1}(S_{t+1}, A_{t+1}) \\right)^2 | P_t] \\\\\n",
        "    & = \\sum_{s'} p(s'|S_t, A_t) \\sum_{a'} \\frac{\\pi(a'|s')^2}{\\mu(a'|s')} \\mathbb{E}_{s''|s'}[G_{t+1}(s', a')^2]\n",
        "        - \\sum_{s'} p(s'|S_t, A_t) \\sum_{a'} \\pi(a'|s') \\mathbb{E}_{s''|s'}[G_{t+1}(s', a')^2] \\\\\n",
        "    & = \\sum_{s'} p(s'|S_t, A_t) \\sum_{a'} \\pi(a'|s') \\mathbb{E}_{s''|s'}[G_{t+1}(s', a')^2] \\left( \\frac{\\pi(a'|s')}{\\mu(a'|s')}  - 1 \\right)\n",
        "    \\end{align*}\n",
        "    $$\n",
        "    Remember that $\\pi$ is a greedy policy and $\\mu$ is a uniform policy, we can classify the terms in the summation according to the two situations of the greedy policy:\n",
        "    - $\\pi(a' | s') = 0$\n",
        "        When the action $a'$ is not a greedy action in state $s'$, the policy returns probability of zero and so the term in summation becomes zero.\n",
        "    - $\\pi(a' | s') > 0$\n",
        "        When the action $a'$ is a greedy action in state $s'$, the policy is greater than zero. Since the maximum number of greedy action in a state is the size of the action space, we have\n",
        "        $$\n",
        "            \\pi(a'| s') \\geq \\frac{1}{|\\mathcal{A}|} \n",
        "            \\Rightarrow\n",
        "            \\frac{\\pi(a'| s')}{\\mu(a'|s')} = |\\mathcal{A}| \\cdot \\pi(a'| s')\n",
        "            \\geq 1\n",
        "        $$\n",
        "        Thus, the term in summation is also greater than or equal to zero.\n",
        "\n",
        "    To conclude, the difference in variance is always greater than or equal to zero. The variance of update in this part is expected to be higher than that in Q5.1.\n",
        "\n",
        "##### **(iii) - Behaviour policy with lower variance**\n",
        "\n",
        "To achieve lower variance, $\\mu$ can a policy that acts mostly greedy, for example a $\\epsilon$-greedy policy or a softmax policy on action values. These policies allow infinite exploration of each action in each state. Thus, the predicted action value keeps improving and becomes more accurate. Conceptually, the rewards received would be more stable and less variable due to the higher confidence in action value estimates."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wesi6S866Lyq"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "last_runtime": {
        "build_target": "//learning/deepmind/dm_python:dm_notebook3",
        "kind": "private"
      },
      "name": "UCL RL CW 2024, part IV",
      "private_outputs": true,
      "provenance": [
        {
          "file_id": "1JU6mjNeZzP6ezHB8Vu5YqV-_Q9iN2CVv",
          "timestamp": 1645461208957
        },
        {
          "file_id": "1dkLVv6gagPKbfB1UCY997gOfqOXpeQD-",
          "timestamp": 1645457029049
        },
        {
          "file_id": "1zYag0A0o4ncxyHc2Uq2ESf7CEBhktnv8",
          "timestamp": 1645456932996
        },
        {
          "file_id": "1KK-ZHRlK2WjPv7etN5KHUwEAGnPSOxbI",
          "timestamp": 1645455353656
        },
        {
          "file_id": "/piper/depot/google3/learning/deepmind/research/ucl/assignments_2021/RL_assignment_3.ipynb?cl=368650897",
          "timestamp": 1618589207256
        },
        {
          "file_id": "/piper/depot/google3/learning/deepmind/research/ucl/assignments_2021/RL_assignment_3_solution.ipynb?workspaceId=mtthss:ucluclucl::citc",
          "timestamp": 1618502477520
        },
        {
          "file_id": "1q0yqRznin1Zv5-MduEZbZZU8EF-qfzxJ",
          "timestamp": 1618501430836
        }
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}