MVARL19_part3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rly7ZGiyUKJ6"
   },
   "source": [
    "# Exploration in Linear Bandits\n",
    "\n",
    "The objective of this part is to implement and compare the following strategies for linear bandits:\n",
    "\n",
    "[Optimism in the Face of Uncertainty (LinUCB/OFUL)](https://papers.nips.cc/paper/4417-improved-algorithms-for-linear-stochastic-bandits.pdf)\n",
    "\n",
    "[Thompson Sampling](https://projecteuclid.org/euclid.ejs/1513306870)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "infCxpaRA0XC"
   },
   "source": [
    "## Linear bandit\n",
    "We consider the standard linear bandit setting. At each time $t$, the agent selects an arm $a_t \\in A$ and observes a reward\n",
    "$$\n",
    "r_{a}^t = \\langle \\theta^\\star, \\phi_a^t \\rangle + \\eta_a^t := \\mu_a^t + \\eta_a^t\n",
    "$$\n",
    "where $\\theta^{\\star} \\in \\mathbb{R}^{d}$ is a parameter vector, $\\phi_{a}^t \\in \\mathbb{R}^{d} $ are the features of arm $a$ at time $t$, and $\\eta_{a}^{t}$ is a zero-mean  $\\sigma^2$-subgaussian noise. \n",
    "\n",
    "When the features correspond to the canonical basis, this formulation reduces to multi-armed bandit (MAB) with $d$ arms. In the more general case, the features may depend on a context $x_t$, so that $\\phi_a^t = \\phi(x_t, a)$ denotes the feature vector of a context-action pair $(x_t, a)$ and the resulting setting is the so-called linear contextual bandit.\n",
    "\n",
    "We rely on the following standard assumption on the features and the unknown parameter $\\theta^\\star$.\n",
    "\n",
    "**Assumption.** There exist $B,D \\geq 0$, such that $\\|\\theta^\\star\\|_2 \\leq B$, $\\|\\phi_a^t\\| \\leq D$, and $\\langle \\theta^\\star, \\phi_a^t \\rangle \\in [0,1]$, for all $t$ and $a$.\n",
    "\n",
    "Given a finite horizon $n$, the performance of the agent is measured by its (pseudo)-\\emph{regret}:\n",
    "$$\n",
    "        %R(n) = n \\mu^{\\star} - \\sum_{t=1}^n \\mu_{a_t} = \\sum_{i=1}^K T_i(n) \\Delta_i, \n",
    "        R(n) = \\sum_{t=1}^n \\langle \\theta^\\star, \\phi_{a^\\star}^t \\rangle - \\langle \\theta^\\star, \\phi_{a_t}^t \\rangle ,\n",
    "$$\n",
    "where $a^{\\star}_{t} \\in \\arg\\max_{a} \\langle \\theta^\\star, \\phi_{a}^t \\rangle$ is the optimal action at time $t$.\n",
    "\n",
    "**We consider the simple linear bandit setting:** $\\phi_a^t = \\phi_a, \\; \\forall t$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SlwPdLAwUWfI"
   },
   "outputs": [],
   "source": [
    "!rm -rf mvarl_hands_on/\n",
    "!git clone https://github.com/rlgammazero/mvarl_hands_on.git\n",
    "!cd mvarl_hands_on/ && git fetch\n",
    "!ls mvarl_hands_on/utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wWQOcbHbUKJ8"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.insert(0, './mvarl_hands_on/utils')\n",
    "import os\n",
    "import numpy as np\n",
    "from pprint import pprint\n",
    "from coldstart import ColdStartFromDataset\n",
    "from scipy.sparse.linalg import svds\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import multivariate_normal\n",
    "import math\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "78oy9izEUKKA"
   },
   "source": [
    "#### Jester Jokes Dataset (Dense subset of 40 jokes)\n",
    "\n",
    "Deep Bayesian Bandits Showdown: An Empirical Comparison of Bayesian Deep Networks for Thompson Sampling\n",
    "\n",
    "Download the data at: https://storage.googleapis.com/bandits_datasets/jester_data_40jokes_19181users.npy\n",
    "\n",
    "We performed a matrix factorization of the ratings (after filtering over users and jokes). This provides features for the arms and users, the reward (ie rating) is the dot product between the arm and user features (we make it stochastic by adding Gaussian noise). We consider a cold start problem where the user is randomly selected at the beginning of the repetition and the agent has to learn the best arm to recommend. When an arm is selected by the algorithm, its reward is computed as the dot product between the arm and user features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HW1YAyl1UKKB"
   },
   "outputs": [],
   "source": [
    "!wget https://storage.googleapis.com/bandits_datasets/jester_data_40jokes_19181users.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7ZsqokZKUKKD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U: (19181, 35)\n",
      "Vt: (35, 40)\n",
      "#features: 35\n",
      "#arms: 40\n"
     ]
    }
   ],
   "source": [
    "M = np.load('jester_data_40jokes_19181users.npy')\n",
    "M = M / 10\n",
    "K = 35\n",
    "U, s, Vt = svds(M, k = K)\n",
    "s=np.diag(s)\n",
    "U = np.dot(U,s)\n",
    "print('U: {}'.format(U.shape))\n",
    "print('Vt: {}'.format(Vt.shape))\n",
    "print('#features: {}'.format(Vt.shape[0]))\n",
    "print('#arms: {}'.format(Vt.shape[1]))\n",
    "np.savetxt('U_jester.csv', U, delimiter=',') \n",
    "np.savetxt('Vt_jester.csv', Vt, delimiter=',') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VmQdkpc-UKKF"
   },
   "source": [
    "Create the coldstart model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fDXGgf-HUKKF"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current config is:\n",
      "{'arm_csvfile': '/home/manifold/Documents/pyprojects/mva-rl/Vt_jester.csv',\n",
      " 'noise_std': 0.1,\n",
      " 'random_state': 1235,\n",
      " 'user_csvfile': '/home/manifold/Documents/pyprojects/mva-rl/U_jester.csv',\n",
      " 'user_subset': [0, 44, 88, 133, 177, 222, 266, 311, 355, 400]}\n"
     ]
    }
   ],
   "source": [
    "seed = 1235\n",
    "user_subset = np.linspace(0, 400, 10).astype(int).tolist()\n",
    "arm_csvfile = os.path.abspath('Vt_jester.csv')\n",
    "user_csvfile = os.path.abspath('U_jester.csv')\n",
    "noise_std = 0.1\n",
    "\n",
    "config_cs = {\n",
    "    'arm_csvfile': arm_csvfile,\n",
    "    'user_csvfile': user_csvfile,\n",
    "    'random_state': seed,\n",
    "    'user_subset': user_subset,\n",
    "    'noise_std': noise_std\n",
    "}\n",
    "\n",
    "print(\"Current config is:\")\n",
    "pprint(config_cs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cjPeT4LLUKKH"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The new user arriving to the system is user # 222\n",
      "\n",
      "Theta*:  [ 0.60768701  0.22282253 -0.22643899  0.02040195  0.59490395  0.44860969\n",
      " -0.6017342   0.51336444 -0.33916609  1.08450089  0.19933839  0.31922471\n",
      "  0.14813868  0.33235693  0.1490287  -0.03148608 -0.52536238  0.15506547\n",
      " -0.35049923 -0.04381107 -0.30580771  0.6075547  -0.7093192  -0.12169536\n",
      " -0.59119731  0.751896   -0.12526202  0.96516389  0.15991881  0.95369292\n",
      "  0.13907613  0.49802877  0.50969068 -1.1405248   1.99847038]\n",
      "\n",
      "Means:  [0.03166748 1.         0.7812777  0.86211556 0.47401511 0.78737614\n",
      " 0.7220526  0.53701573 0.35024036 0.71579278 0.81149121 0.1887264\n",
      " 0.78713313 0.88226533 0.02188491 0.62244738 0.74552921 0.44693205\n",
      " 0.57882853 0.63138315 0.01585463 0.48629039 0.7895057  0.83992301\n",
      " 0.77264996 0.69231019 0.6554525  0.65802771 0.74321219 0.7367446\n",
      " 0.69337476 0.36425563 0.02093084 0.75762399 0.42779578 0.74545807\n",
      " 0.73585842 0.67338801 0.         0.70343108]\n",
      "\n",
      "Theta bound:  3.642015724562846\n"
     ]
    }
   ],
   "source": [
    "noise = 0.4\n",
    "random_state = 312\n",
    "model = ColdStartFromDataset(**config_cs)\n",
    "print(\"\\nThe new user arriving to the system is user #\", model.theta_idx)\n",
    "print(\"\\nTheta*: \", model.theta)\n",
    "means = np.dot(model.features, model.theta)\n",
    "print(\"\\nMeans: \", means)\n",
    "theta_bound = np.linalg.norm(model.theta, 2)\n",
    "print(\"\\nTheta bound: \", theta_bound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature dimension: (35,)\n",
      "Number of arms (jokes): 40\n"
     ]
    }
   ],
   "source": [
    "print(\"Feature dimension:\", model.theta.shape)\n",
    "\n",
    "print(\"Number of arms (jokes):\", model.features.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6KUmWBFlUKKJ"
   },
   "source": [
    "**Question 1**: implement LinUCB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G45BzTW_J4Gr"
   },
   "source": [
    "### LinUCB / OFUL\n",
    "See the slides!\n",
    "\n",
    "Note that it is not necessary to invert the matrix $A_t$ at each round. Since $A_t$ is obtained from a rank-1 update of $A_{t-1}$, it is possible to use Sherman–Morrison formula to build directly $A_t^{-1}$.\n",
    "\n",
    "Suppose $𝐴$ be a nonsingular $n\\times n$ matrix and $\\mathbf{u}, \\mathbf{v}$ be vectors. Then\n",
    "$$\n",
    "(A+\\mathbf{u}\\mathbf{v}^T)^{-1} = A^{-1} - \\frac{A^{-1}\\mathbf{u}\\mathbf{v}^TA^{-1}}{1+\\mathbf{v}^TA^{-1}\\mathbf{u}}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AxRC2xoAUKKJ"
   },
   "outputs": [],
   "source": [
    "def compute_A_norm(A, x: np.ndarray):\n",
    "    \"\"\"Compute the A-norm of the vector x\n",
    "    \n",
    "    Returns:\n",
    "        float, or\n",
    "        array of shape (n_vecs,)\n",
    "    \"\"\"\n",
    "    if x.ndim == 1:\n",
    "        norm2 = x @ (A @ x)\n",
    "    else:\n",
    "        # expect x of shape (n_vecs, dim)\n",
    "        norm2 = [\n",
    "            u @ (A @ u) for u in x\n",
    "        ]\n",
    "    return np.sqrt(norm2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AxRC2xoAUKKJ"
   },
   "outputs": [],
   "source": [
    "class OFUL:\n",
    "    def __init__(self, arm_features, reg_factor, delta,\n",
    "                 bound_theta, noise_std):\n",
    "        self.arm_features = arm_features  # shape (n_arms, n_features)\n",
    "        self.reg_factor = reg_factor\n",
    "        self.delta = delta\n",
    "        self.iteration = None  # time t\n",
    "        self.bound_theta = bound_theta  # bound B\n",
    "        self.bound_features = np.max(np.sqrt(np.sum(arm_features ** 2, axis=1)))\n",
    "        self.noise_std = noise_std\n",
    "        \n",
    "        self.A_t_inv = None\n",
    "        self.b_t = None\n",
    "        self.theta_t = None\n",
    "        \n",
    "        self.reset()\n",
    "\n",
    "    @property\n",
    "    def n_actions(self):\n",
    "        \"\"\"No. of actions A\"\"\"\n",
    "        return self.arm_features.shape[0]\n",
    "\n",
    "    @property\n",
    "    def n_features(self):\n",
    "        \"\"\"Dim of features d\"\"\"\n",
    "        return self.arm_features.shape[1]\n",
    "    \n",
    "    def reset(self):\n",
    "        self.iteration = 0\n",
    "        \n",
    "        self.A_t_inv = self.reg_factor*np.eye(\n",
    "            self.arm_features.shape[1])  # shape (n_features, n_features)\n",
    "        self.b_t = np.zeros(self.arm_features.shape[1])\n",
    "        self.theta_t = np.zeros(self.arm_features.shape[1])\n",
    "        \n",
    "        return self.mu()\n",
    "    \n",
    "    def mu(self):\n",
    "        return self.arm_features @ self.theta_t\n",
    "    \n",
    "    def alpha(self, n_samples):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            n_samples: time\n",
    "        \"\"\"\n",
    "        d = self.n_features\n",
    "        sgm_ = self.noise_std\n",
    "        L_ = self.bound_features\n",
    "        res = sgm_ * np.sqrt(\n",
    "            d * np.log((1 + n_samples*L_**2/self.reg_factor) / self.delta)\n",
    "        ) + self.reg_factor ** .5 * self.bound_theta\n",
    "        return res\n",
    "    \n",
    "    def sample_action(self):\n",
    "        \"\"\"Return the action to play based on current estimates\n",
    "        \"\"\"\n",
    "        phi_norm = compute_A_norm(self.A_t_inv, self.arm_features)  # shape (n_arms,)\n",
    "        alph = self.alpha(self.iteration)\n",
    "        upper_bound = self.mu() + alph*phi_norm  # shape (n_arms,)\n",
    "        action = np.argmax(upper_bound)\n",
    "        return action\n",
    "    \n",
    "    def update(self, a_t, r_t):\n",
    "        \"\"\"Update the estimates of the model\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        a_t: int\n",
    "            The action played at the current episode\n",
    "        r_t: float\n",
    "            The reward associated to action a_t\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        none\n",
    "        \"\"\"\n",
    "        self.iteration += 1\n",
    "        \n",
    "        feat_action = self.arm_features[a_t, None].T  # shape (n_features, 1)\n",
    "        # Apply Sherman-Morrison formula\n",
    "        numer = (self.A_t_inv @ feat_action) @ (feat_action.T @ self.A_t_inv)\n",
    "        denom = 1 + feat_action.T @ (self.A_t_inv @ feat_action)\n",
    "        \n",
    "        self.A_t_inv[:] = self.A_t_inv - numer / denom\n",
    "        self.b_t += self.arm_features[a_t] * r_t  # shape (n_features,)\n",
    "        self.theta_t = self.A_t_inv @ self.b_t\n",
    "        \n",
    "        return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OtwYcKlrK6UP"
   },
   "source": [
    "**Question 2:** implement LinearTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9xl29-B3MEOC"
   },
   "source": [
    "Let $A_t$ be the design matrix, $\\theta_t$ the estimate of $\\theta^\\star$ and $\\beta_t$ the confidence interval built by LinUCB. Then, at every time step t,  LinearTS simply generates\n",
    "a sample $\\tilde{\\theta}_t$ from the distribution $\\mathcal{N}(\\widehat{\\theta}_t, \\omega_t \\alpha_t^2 A_t^{-1})$.\n",
    "\n",
    "LinearTS\n",
    "\n",
    "For $t=1, \\ldots, T$\n",
    "> $\\tilde{\\theta}_t \\sim \\mathcal{N}(\\widehat{\\theta}_t, \\omega_t \\alpha_t^2 A_t^{-1})$\n",
    ">\n",
    "> $a_t \\in \\arg\\max_{a \\in \\mathcal{A}_t}  \\langle \\tilde{\\theta}_t, \\phi_{a} \\rangle$\n",
    ">\n",
    "> observe reward $r_t$\n",
    "\n",
    "TS is requires to draw $\\tilde{\\theta}_t$ from a distribution over-sampling by a factor $\\sqrt{d}$ the ellipsoid constructed by OFUL (i.e., $\\omega_t = d$). This is required to prove that LinearTS is optimistic with a fix probability. This is necessary to prove the frequentist regret of TS. The regret of TS is worse than the one of LinUCB by a factor $\\sqrt{d}$ (i.e., $\\widetilde{O}(d^{3/2}\\sqrt{T})$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zTJh0yqgUKKM"
   },
   "outputs": [],
   "source": [
    "class LinearTS(OFUL):\n",
    "    def __init__(self, arm_features, reg_factor, delta,\n",
    "                 bound_theta, noise_std):\n",
    "        super(LinearTS, self).__init__(arm_features, reg_factor, delta,\n",
    "                 bound_theta, noise_std)\n",
    "        \n",
    "    def sample_action(self):\n",
    "        \"\"\"\n",
    "        Return the action to play with LinearTS\n",
    "        \"\"\"\n",
    "        omega = self.n_features  # d\n",
    "        # omega = 1.  # for testing: bad results!\n",
    "        # sample from N(theta_t, omega * alpha2 * At-1)\n",
    "        alph = self.alpha(self.iteration)\n",
    "        cov = omega * alph ** 2 * self.A_t_inv\n",
    "        sample_theta = np.random.multivariate_normal(self.theta_t, cov)\n",
    "        samp_mu = self.arm_features @ sample_theta\n",
    "        action = np.argmax(samp_mu)\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kKERx2_UUKKN"
   },
   "source": [
    "**Question 3**: run the algorithms (`LinUCB` and `LinearTS`) and average the performance over multiple users (ie simulations)\n",
    "\n",
    "The regret $R(T) = \\sum_t \\phi_t^\\top (\\theta^\\star - \\theta_t)$\n",
    "\n",
    "The performance is the expected regret over multiple users. You can also test `LinearTS` without the additional $\\sqrt{d}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "urKPGY9vXxRn"
   },
   "source": [
    "You can use `RandomLinearArms` to test your code before using Jester"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Y1pezF4JUKKO"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OFUL simulation 1/4\n",
      "OFUL simulation 2/4\n",
      "OFUL simulation 3/4\n",
      "OFUL simulation 4/4\n",
      "LinearTS simulation 1/4\n",
      "LinearTS simulation 2/4\n",
      "LinearTS simulation 3/4\n",
      "LinearTS simulation 4/4\n"
     ]
    }
   ],
   "source": [
    "from mvarl_hands_on.utils.coldstart import RandomLinearArms\n",
    "\n",
    "nb_simulations = 4\n",
    "# T = int(4e4)\n",
    "T = int(8e3)\n",
    "\n",
    "algorithms = {\n",
    "            'OFUL': lambda arm_features, bound_theta: \n",
    "              OFUL(arm_features=arm_features, reg_factor=1., delta=0.01,\n",
    "                 bound_theta=bound_theta, noise_std=config_cs['noise_std']),\n",
    "             'LinearTS': lambda arm_features, bound_theta:\n",
    "              LinearTS(arm_features=arm_features, reg_factor=1., delta=0.01,\n",
    "                 bound_theta=bound_theta, noise_std=config_cs['noise_std'])\n",
    "             }\n",
    "\n",
    "regrets = {}\n",
    "\n",
    "for alg_name in algorithms.keys():\n",
    "    if alg_name not in regrets.keys():\n",
    "        # initialize the regret\n",
    "        regrets[alg_name] = np.zeros((nb_simulations, T))\n",
    "    \n",
    "    for k in range(nb_simulations):\n",
    "        if k % 1 == 0:\n",
    "            print(\"{} simulation {}/{}\".format(alg_name, k+1, nb_simulations))\n",
    "        model = ColdStartFromDataset(**config_cs)\n",
    "        # model = RandomLinearArms()\n",
    "        algo_func = algorithms[alg_name]\n",
    "        alg = algo_func(\n",
    "            arm_features=model.features,\n",
    "            bound_theta=theta_bound)\n",
    "        \n",
    "        for t in range(T):\n",
    "            a_t = alg.sample_action()\n",
    "            r_t = model.reward(a_t)\n",
    "            alg.update(a_t, r_t)\n",
    "            phi = alg.arm_features[a_t]\n",
    "            # recall: theta_star is model.theta\n",
    "            regrets[alg_name][k,t] = phi @ (model.theta - alg.theta_t)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vz5uoLmvUKKP"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f95e5393668>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 465,
       "width": 592
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,8))\n",
    "for alg_name in regrets.keys():\n",
    "    data = np.cumsum(regrets[alg_name], axis=1)\n",
    "    n_rep, T = data.shape\n",
    "    \n",
    "    mean_regret = np.mean(data, axis=0)\n",
    "    std_regret = np.std(data, axis=0) / math.sqrt(n_rep)\n",
    "    t = np.arange(T)\n",
    "    plt.plot(t, mean_regret, label=alg_name)\n",
    "    plt.fill_between(t, mean_regret - 2 * std_regret, mean_regret + 2 * std_regret, alpha=0.15)\n",
    "plt.legend()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(\"regret_jester.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "MVARL19_part3.ipynb",
   "private_outputs": true,
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}