var.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "import numpy as np\n",
    "from math import *\n",
    "from bandits import *\n",
    "from scipy.special import ndtri, erfinv\n",
    "from scipy.stats import norm\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bandit Setting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "#As in Paper 1\n",
    "\n",
    "#best mean arm = best var arm\n",
    "# Arms = [(1, 5), (5, 5)]\n",
    "#best mean arm != best var arm\n",
    "# Arms = [(1, 1), (3, 15)]\n",
    "#A\n",
    "Arms = [(2, 1), (3, 1.5), (4, 5), (2, 2.5), (1, 1.5)]\n",
    "#B\n",
    "# Arms = [(1, 1), (3, 4), (5, 15), (7, 1), (9, 15)]\n",
    "K = len(Arms)\n",
    "bandit = gaussian_bandit(K, Arms)\n",
    "\n",
    "#Parameters\n",
    "#Number of rounds\n",
    "n = 1000\n",
    "#\n",
    "trials = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[0.35514637304852714,\n",
       " 0.9854739562013299,\n",
       " 0.32199547709942644,\n",
       " -0.6007419393777882,\n",
       " -1.01452604379867]"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "epsilon = 0.05 #the low probability thingy\n",
    "a = sqrt(2.)*erfinv(2*epsilon - 1)\n",
    "\n",
    "#Best arm\n",
    "#calculate true VaR\n",
    "true_vs = [norm.ppf(epsilon, loc = arm[0], scale = sqrt(arm[1])) for arm in Arms]\n",
    "best_arm = np.argmax(true_vs)\n",
    "v_best = true_vs[best_arm]\n",
    "best_arm\n",
    "true_vs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UCB - Risk Neutral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Regret', 5.419886765386744)\n",
      "('Cumulative Regret', 653.1509038770425)\n",
      "('Perc optimal', 0.04109999999999999)\n",
      "[13, 31, 937, 10, 9]\n",
      "[0.9674670045238107, 1.2285092369367452, -4.802935239670433, -5.797228929691175, -1.5795179512760549]\n"
     ]
    }
   ],
   "source": [
    "#UCB\n",
    "\n",
    "regret_trials_0 = []\n",
    "cum_regret_trials_0 = []\n",
    "perc_optimal_trials_0 = []\n",
    "for trial in range(trials):\n",
    "\n",
    "    #Sample means and variances\n",
    "    sample_rewards = [[] for k in range(K)]\n",
    "    sample_means = [0]*K\n",
    "    sample_vars = [0]*K\n",
    "    net_rewards = []\n",
    "    net_v = 0\n",
    "    #mean-variance values\n",
    "    vs = [0]*K\n",
    "    #UCB values\n",
    "    Bs = [0]*K\n",
    "    #Number of times each arm is played\n",
    "    num_played = [0]*K\n",
    "    #Risk-averse regret\n",
    "    regret_till_now = 0\n",
    "    cum_regret_till_now = 0\n",
    "    regret = []\n",
    "    cum_regret = []\n",
    "    perc_optimal = []\n",
    "\n",
    "    for i in range(K):\n",
    "        #Pull arm\n",
    "        reward = bandit.pull_arm(i)\n",
    "        #Add reward to list of rewards\n",
    "        sample_rewards[i].append(reward)\n",
    "        net_rewards.append(reward)\n",
    "        #Add reward to mean, variance is zero so no need to update\n",
    "        sample_means[i] = reward\n",
    "        #Update arm played count\n",
    "        num_played[i] += 1  \n",
    "        vs[i] = sample_means[i] + a*sqrt(sample_vars[i])\n",
    "        net_v = np.mean(net_rewards) + a*sqrt(np.var(net_rewards))\n",
    "        regret_till_now = v_best - net_v\n",
    "        cum_regret_till_now += v_best - true_vs[i]\n",
    "        regret.append(regret_till_now)\n",
    "        cum_regret.append(cum_regret_till_now)\n",
    "        perc_optimal.append(num_played[best_arm]/float(i+1)) \n",
    "\n",
    "    for t in range(K+1, n+1):\n",
    "        #Calculate  UCBs\n",
    "        Bs = [mean + np.sqrt(8*np.log(t)/num) for mean, num in zip(sample_means, num_played)]\n",
    "\n",
    "        #Pull best arm\n",
    "        arm_to_pull = np.argmax(Bs)\n",
    "        reward = bandit.pull_arm(arm_to_pull)\n",
    "        sample_rewards[arm_to_pull].append(reward)\n",
    "        net_rewards.append(reward)\n",
    "        num_played[arm_to_pull] += 1\n",
    "\n",
    "        #Update means\n",
    "        sample_means[arm_to_pull] = np.mean(sample_rewards[arm_to_pull])\n",
    "        sample_vars[arm_to_pull] = np.var(sample_rewards[arm_to_pull])\n",
    "        vs[arm_to_pull] = sample_means[arm_to_pull] + a*sample_vars[arm_to_pull]   \n",
    "        net_v = np.mean(net_rewards) + a*np.var(net_rewards)\n",
    "\n",
    "        #Update regret\n",
    "        regret_till_now = v_best - net_v\n",
    "        cum_regret_till_now += v_best - true_vs[arm_to_pull]\n",
    "        regret.append(regret_till_now)\n",
    "        cum_regret.append(cum_regret_till_now)\n",
    "        perc_optimal.append(num_played[best_arm]/float(t)) \n",
    "\n",
    "    regret_trials_0.append(regret)\n",
    "    cum_regret_trials_0.append(cum_regret)\n",
    "    perc_optimal_trials_0.append(perc_optimal)\n",
    "\n",
    "regret_avg_0 = np.mean(np.array(regret_trials_0), axis = 0)\n",
    "cum_regret_avg_0 = np.mean(np.array(cum_regret_trials_0), axis = 0)\n",
    "perc_optimal_avg_0 = np.mean(np.array(perc_optimal_trials_0), axis = 0)\n",
    "print(\"Regret\", regret_avg_0[-1])\n",
    "print(\"Cumulative Regret\", cum_regret_avg_0[-1])\n",
    "print(\"Perc optimal\", perc_optimal_avg_0[-1])\n",
    "print(num_played)  #of the last trial\n",
    "print(vs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VaR - UCB (Paper 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Regret', 0.3092582805872256)\n",
      "('Cumulative Regret', 281.986584948125)\n",
      "('Perc optimal', 0.5886999999999999)\n",
      "[5, 980, 5, 5, 5]\n",
      "[-0.18204088893442982, 0.912880454330911, 0.5552387503497993, -0.2961815309748901, -1.111711981082014]\n"
     ]
    }
   ],
   "source": [
    "#b - refer paper\n",
    "b = 0.1\n",
    "\n",
    "regret_trials_1 = []\n",
    "perc_optimal_trials_1 = []\n",
    "cum_regret_trials_1 = []\n",
    "for trial in range(trials):\n",
    "    \n",
    "    #All arms in the set initially\n",
    "    S = set(range(K))\n",
    "\n",
    "    #Sample means and variances\n",
    "    sample_rewards = [[] for k in range(K)]\n",
    "    sample_means = [0]*K\n",
    "    sample_vars = [0]*K\n",
    "    net_rewards = []\n",
    "    net_v = 0\n",
    "    #var values\n",
    "    vs = [0]*K\n",
    "    #Number of times each arm is played\n",
    "    num_played = [0]*K\n",
    "    #Risk-averse regret\n",
    "    regret_till_now = 0\n",
    "    cum_regret_till_now = 0\n",
    "    regret = []\n",
    "    cum_regret = []\n",
    "    perc_optimal = []\n",
    "    #Whether time horizon has been reached\n",
    "    done = False\n",
    "    #Delta - refer paper\n",
    "    Delta = 1.0\n",
    "    #rounds count\n",
    "    rounds = 0\n",
    "\n",
    "    for m in range(n):\n",
    "        #(1)\n",
    "        #Calculate n_m\n",
    "        n_m = ceil(64 * b**2 * np.log(n) / (Delta**2))\n",
    "\n",
    "        if len(S) == 1:\n",
    "            i = list(S)[0]\n",
    "            #print(num_played, n)\n",
    "            while(sum(num_played) < n):\n",
    "                #Pull arm\n",
    "                reward = bandit.pull_arm(i)\n",
    "                sample_rewards[i].append(reward)\n",
    "                net_rewards.append(reward)\n",
    "                sample_means[i] = np.mean(sample_rewards[i])\n",
    "                sample_vars[i] = np.var(sample_rewards[i])\n",
    "                num_played[i] += 1  \n",
    "                rounds += 1\n",
    "                vs[i] = sample_means[i] + a*sqrt(sample_vars[i])\n",
    "                net_v = np.mean(net_rewards) + a*sqrt(np.var(net_rewards))\n",
    "                regret_till_now = v_best - net_v\n",
    "                cum_regret_till_now += v_best - true_vs[i]\n",
    "                regret.append(regret_till_now)\n",
    "                cum_regret.append(cum_regret_till_now)\n",
    "                perc_optimal.append(num_played[best_arm]/float(rounds)) \n",
    "            done = True\n",
    "        else:\n",
    "            for i in S: \n",
    "                while(num_played[i] < n_m):\n",
    "                    #Pull arm\n",
    "                    reward = bandit.pull_arm(i)\n",
    "                    #Add reward to list of rewards\n",
    "                    sample_rewards[i].append(reward)\n",
    "                    net_rewards.append(reward)\n",
    "                    #Update means and variances and mean-variance\n",
    "                    sample_means[i] = np.mean(sample_rewards[i])\n",
    "                    sample_vars[i] = np.var(sample_rewards[i])\n",
    "                    num_played[i] += 1  \n",
    "                    rounds += 1\n",
    "                    #Update V\n",
    "                    vs[i] = sample_means[i] + a*sqrt(sample_vars[i])\n",
    "                    net_v = np.mean(net_rewards) + a*sqrt(np.var(net_rewards))\n",
    "                    #Update regret\n",
    "                    regret_till_now = v_best - net_v##Check\n",
    "                    cum_regret_till_now += v_best - true_vs[i]\n",
    "                    regret.append(regret_till_now)\n",
    "                    cum_regret.append(cum_regret_till_now)\n",
    "                    perc_optimal.append(num_played[best_arm]/float(rounds)) \n",
    "                    \n",
    "                    if rounds >= n:\n",
    "                        done = True\n",
    "                        break\n",
    "                if done:\n",
    "                    break                    \n",
    "        if done:\n",
    "            break\n",
    "        #(2)\n",
    "        #Remove arms\n",
    "        #Find min_ucb\n",
    "        max_lcb = -np.inf\n",
    "        for arm in S:\n",
    "            if vs[arm] - b*sqrt(log(n)/n_m) > max_lcb:\n",
    "                max_lcb = vs[arm] - b*sqrt(log(n)/n_m)\n",
    "        to_remove = []\n",
    "        for arm in S:\n",
    "            if vs[arm] + b*sqrt(log(n)/n_m) < max_lcb: \n",
    "                to_remove.append(arm)\n",
    "        for arm in to_remove:\n",
    "            S.remove(arm)    \n",
    "        #(3)\n",
    "        Delta = Delta/2 \n",
    "        \n",
    "    regret_trials_1.append(regret)\n",
    "    perc_optimal_trials_1.append(perc_optimal)\n",
    "    cum_regret_trials_1.append(cum_regret)\n",
    "    \n",
    "regret_avg_1 = np.mean(np.array(regret_trials_1), axis = 0)\n",
    "perc_optimal_avg_1 = np.mean(np.array(perc_optimal_trials_1), axis = 0)\n",
    "cum_regret_avg_1 = np.mean(np.array(cum_regret_trials_1), axis = 0)\n",
    "print(\"Regret\", regret_avg_1[-1])\n",
    "print(\"Cumulative Regret\", cum_regret_avg_1[-1])\n",
    "print(\"Perc optimal\", perc_optimal_avg_1[-1])\n",
    "print(num_played)  #of the last trial\n",
    "print(vs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VaR-ETC (New)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Regret', 1.0621903010247613)\n",
      "('Cumulative Regret', 253.5563478709922)\n",
      "('Perc optimal', 0.71)\n",
      "[30, 880, 30, 30, 30]\n",
      "[-0.841465056245057, 0.5901306103851094, -5.4737110214396, -4.295066145008171, -0.9662647518404928]\n"
     ]
    }
   ],
   "source": [
    "tau = 30\n",
    "\n",
    "regret_trials_2 = []\n",
    "cum_regret_trials_2 = []\n",
    "perc_optimal_trials_2 = []\n",
    "for trial in range(trials):\n",
    "    \n",
    "    #Sample means and variances\n",
    "    sample_rewards = [[] for k in range(K)]\n",
    "    sample_means = [0]*K\n",
    "    sample_vars = [0]*K\n",
    "    net_rewards = []\n",
    "    net_v = 0\n",
    "    #mean-variance values\n",
    "    vs = [0]*K\n",
    "    #Number of times each arm is played\n",
    "    num_played = [0]*K\n",
    "    #Risk-averse regret\n",
    "    regret_till_now = 0\n",
    "    cum_regret_till_now = 0\n",
    "    regret = []\n",
    "    cum_regret = []\n",
    "    perc_optimal = []\n",
    "\n",
    "\n",
    "    for i in range(K):\n",
    "        for j in range(tau):\n",
    "            #Pull arm\n",
    "            reward = bandit.pull_arm(i)\n",
    "            #Add reward to list of rewards\n",
    "            sample_rewards[i].append(reward)\n",
    "            net_rewards.append(reward)\n",
    "            #Mean\n",
    "            sample_means[i] = np.mean(sample_rewards[i])\n",
    "            #Variance\n",
    "            sample_vars[i] = np.var(sample_rewards[i])\n",
    "            #Update arm played count\n",
    "            num_played[i] += 1   \n",
    "            #Update V\n",
    "            vs[i] = sample_means[i] + a*sample_vars[i]   \n",
    "            net_v = np.mean(net_rewards) + a*np.var(net_rewards)\n",
    "            #Update regret\n",
    "            regret_till_now = v_best - net_v\n",
    "            cum_regret_till_now += v_best - true_vs[i]\n",
    "            regret.append(regret_till_now)\n",
    "            cum_regret.append(cum_regret_till_now)\n",
    "            perc_optimal.append(num_played[best_arm]/float(i*tau+j+1)) \n",
    "            \n",
    "\n",
    "    exploit_arm = np.argmax(vs)\n",
    "    for i in range(tau*K+1, n+1):\n",
    "        reward = bandit.pull_arm(exploit_arm)\n",
    "        sample_rewards[exploit_arm].append(reward)\n",
    "        net_rewards.append(reward)\n",
    "        sample_means[exploit_arm] = np.mean(sample_rewards[exploit_arm])\n",
    "        sample_vars[exploit_arm] = np.var(sample_rewards[exploit_arm])\n",
    "        num_played[exploit_arm] += 1\n",
    "\n",
    "        vs[exploit_arm] = sample_means[exploit_arm] + a*sample_vars[exploit_arm]\n",
    "        net_v = np.mean(net_rewards) + a*np.var(net_rewards)\n",
    "    \n",
    "        #Update regret\n",
    "        regret_till_now = v_best - net_v\n",
    "        cum_regret_till_now += v_best - true_vs[exploit_arm]\n",
    "        regret.append(regret_till_now)\n",
    "        cum_regret.append(cum_regret_till_now)\n",
    "        perc_optimal.append(num_played[best_arm]/float(i))\n",
    "\n",
    "    regret_trials_2.append(regret)\n",
    "    cum_regret_trials_2.append(cum_regret)\n",
    "    perc_optimal_trials_2.append(perc_optimal) \n",
    "\n",
    "regret_avg_2 = np.mean(np.array(regret_trials_2), axis = 0)\n",
    "cum_regret_avg_2 = np.mean(np.array(cum_regret_trials_2), axis = 0)\n",
    "perc_optimal_avg_2 = np.mean(np.array(perc_optimal_trials_2), axis = 0)\n",
    "print(\"Regret\", regret_avg_2[-1])\n",
    "print(\"Cumulative Regret\", cum_regret_avg_2[-1])\n",
    "print(\"Perc optimal\", perc_optimal_avg_2[-1])\n",
    "print(num_played)  #of the last trial\n",
    "print(vs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b31fd5590>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b31fd56d0>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b31c0d690>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'n')"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'regret')"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f7b31fd5850>"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b31bc3790>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b31bc3f10>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b31b638d0>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'n')"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'perc of times optimal arm was played')"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f7b31bc3fd0>"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b3187fd90>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b3187f4d0>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b3187fa10>]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'n')"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'cum regret')"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f7b3187f750>"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "save = True\n",
    "problem_id = \"A\"\n",
    "\n",
    "#Plot regret vs rounds\n",
    "plt.plot(regret_avg_0 , color = \"yellow\", label = \"UCB\")\n",
    "plt.plot(regret_avg_1 , color = \"blue\", label = \"VaR-UCB\")\n",
    "plt.plot(regret_avg_2 , color = \"green\", label = \"VaR-ETC\")\n",
    "plt.xlabel('n')\n",
    "plt.ylabel('regret')\n",
    "plt.legend()\n",
    "if save == True:\n",
    "    plt.savefig('var_' + problem_id + '_reg.png')\n",
    "plt.show()\n",
    "\n",
    "#Plot percentage optimal vs rounds\n",
    "plt.plot(perc_optimal_avg_0 , color = \"yellow\", label = \"UCB\")\n",
    "plt.plot(perc_optimal_avg_1 , color = \"blue\", label = \"VaR-UCB\")\n",
    "plt.plot(perc_optimal_avg_2 , color = \"green\", label = \"VaR-ETC\")\n",
    "plt.xlabel('n')\n",
    "plt.ylabel('perc of times optimal arm was played')\n",
    "plt.legend()\n",
    "if save == True:\n",
    "    plt.savefig('var_' + problem_id + '_perc.png')\n",
    "plt.show()\n",
    "\n",
    "#Regret :\n",
    "plt.plot(cum_regret_avg_0 , color = \"yellow\", label = \"UCB\")\n",
    "plt.plot(cum_regret_avg_1, color = \"blue\", label = \"VaR-UCB\")\n",
    "plt.plot(cum_regret_avg_2 , color = \"green\", label = \"VaR-ETC\")\n",
    "plt.xlabel('n')\n",
    "plt.ylabel('cum regret')\n",
    "plt.legend()\n",
    "if save == True:\n",
    "    plt.savefig('var_' + problem_id + '_cumreg.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}