CVaR.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 106,
   "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\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": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "#As in Paper 1\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": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "def std_normal(y):\n",
    "    return np.exp(-(y**2)/2.)/sqrt(2.*pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-0.0627128075074257,\n",
       " 0.47370306785153415,\n",
       " -0.6123660556460431,\n",
       " -1.261435315261966,\n",
       " -1.5262969321484658]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0.10313564037537139"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "epsilon = 0.05 #quantile\n",
    "alpha = 1. - epsilon\n",
    "\n",
    "#Best arm\n",
    "true_cvs = [arm[0] - sqrt(arm[1])*std_normal(ndtri(alpha))/(1.- alpha) for arm in Arms]\n",
    "true_cvs = [arm[0] - sqrt(arm[1])*std_normal(ndtri(alpha))/(1.- alpha) for arm in Arms]\n",
    "best_arm = np.argmax(true_cvs)\n",
    "cv_best = true_cvs[best_arm]\n",
    "true_cvs\n",
    "best_arm\n",
    "\n",
    "std_normal(ndtri(alpha))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UCB - Risk Neutral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Regret', 1.1736470914553623)\n",
      "('Cumulative Regret', 1049.3022361722383)\n",
      "('Perc optimal', 0.0399)\n",
      "[9, 60, 908, 14, 9]\n",
      "[0.7164979355110688, 0.40872576397635, -0.83817172733385, -0.7352670491450013, -0.1847271905437562]\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_cv = 0\n",
    "    #mean-variance values\n",
    "    cvs = [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",
    "        #Update arm played count\n",
    "        num_played[i] += 1  \n",
    "        sample_means[i] = reward\n",
    "        \n",
    "        #Update CV\n",
    "        cvs[i] = reward\n",
    "        if i == 0:\n",
    "            net_cv = reward\n",
    "        else:   \n",
    "            net_rewards.sort()\n",
    "            net_cv = float(sum(net_rewards[:int(np.ceil(len(net_rewards)*epsilon))]\\\n",
    "                              ))/np.ceil(len(net_rewards)*epsilon)\n",
    "        \n",
    "        #Update regret\n",
    "        regret_till_now = cv_best - net_cv\n",
    "        cum_regret_till_now += cv_best - true_cvs[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_rewards[arm_to_pull].sort()\n",
    "        net_rewards.sort()\n",
    "        cvs[arm_to_pull] = float(sum(sample_rewards[arm_to_pull][:int(np.ceil(len(sample_rewards[arm_to_pull])*epsilon))]\\\n",
    "                          ))/np.ceil(len(sample_rewards[arm_to_pull])*epsilon)\n",
    "        net_cv = float(sum(net_rewards[:int(np.ceil(len(net_rewards)*epsilon))]\\\n",
    "                          ))/np.ceil(len(net_rewards)*epsilon)\n",
    "        #Update regret\n",
    "        regret_till_now = cv_best - net_cv\n",
    "        cum_regret_till_now += cv_best - true_cvs[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(cvs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MARAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Regret', 0.3837071864010945)\n",
      "('Cumulative Regret', 400.10756643733714)\n",
      "('Perc optimal', 0.5872872872872873)\n",
      "[971, 5, 14, 5, 5]\n",
      "[-0.07311800690199848, 0.1811367130371333, -0.3853111804970082, 0.029924700811717164, -0.6085954784414127]\n"
     ]
    }
   ],
   "source": [
    "#refer paper\n",
    "C = 2 # greater than 0\n",
    "\n",
    "regret_trials_1 = []\n",
    "perc_optimal_trials_1 = []\n",
    "cum_regret_trials_1 = []\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_cv = 0\n",
    "    \n",
    "    #cvar values\n",
    "    cvs = [0]*K\n",
    "    #indices\n",
    "    Is = [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",
    "    #rounds count\n",
    "    rounds = 0\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",
    "        #Update arm played count\n",
    "        num_played[i] += 1   \n",
    "        \n",
    "        #Update cvar\n",
    "        cvs[i] = reward\n",
    "        if i == 0:\n",
    "            net_cv = reward\n",
    "        else:   \n",
    "            net_rewards.sort()\n",
    "            net_cv = float(sum(net_rewards[:int(np.ceil(len(net_rewards)*epsilon))]\\\n",
    "                              ))/np.ceil(len(net_rewards)*epsilon)\n",
    "        \n",
    "        #Update regret\n",
    "        regret_till_now = cv_best - net_cv\n",
    "        cum_regret_till_now += cv_best - true_cvs[i]\n",
    "        regret.append(regret_till_now)\n",
    "        cum_regret.append(cum_regret_till_now)\n",
    "        perc_optimal.append(num_played[best_arm]) \n",
    "        \n",
    "    \n",
    "    for i in range(K, n):\n",
    "        #indices\n",
    "        Is = [cv - sqrt(C*np.log(np.ceil(i*epsilon))/np.ceil(epsilon*num)) for cv, num in zip(cvs, num_played)]\n",
    "        arm_to_pull = np.argmax(Is)\n",
    "        \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 cvar\n",
    "        sample_rewards[arm_to_pull].sort()\n",
    "        net_rewards.sort()\n",
    "        cvs[arm_to_pull] = float(sum(sample_rewards[arm_to_pull][:int(np.ceil(len(sample_rewards[arm_to_pull])*epsilon))]\\\n",
    "                          ))/np.ceil(len(sample_rewards[arm_to_pull])*epsilon)\n",
    "        net_cv = float(sum(net_rewards[:int(np.ceil(len(net_rewards)*epsilon))]\\\n",
    "                          ))/np.ceil(len(net_rewards)*epsilon)\n",
    "        \n",
    "        #Update regret\n",
    "        regret_till_now = cv_best - net_cv\n",
    "        cum_regret_till_now += cv_best - true_cvs[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(i))\n",
    "    \n",
    "    regret_trials_1.append(regret)\n",
    "    cum_regret_trials_1.append(cum_regret)\n",
    "    perc_optimal_trials_1.append(perc_optimal)\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(cvs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MARABOUT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cvar_compute(rewards):\n",
    "    n = len(rewards)\n",
    "    cvar = rewards[int(np.ceil(n*epsilon)) - 1] + \\\n",
    "            sum([rewards[j] - rewards[int(np.ceil(n*epsilon)) - 1] \\\n",
    "             for j in range(int(np.floor(n*epsilon)))])/(n*epsilon)\n",
    "        \n",
    "    return cvar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Regret', 1.0936513905230694)\n",
      "('Cumulative Regret', 727.3696794471945)\n",
      "('Perc optimal', 0.37257257257257254)\n",
      "[212, 457, 73, 130, 128]\n",
      "[-0.2894417937263756, 0.6446966442889311, -2.3094466775386, -1.0195401328282014, -1.0494773861567372]\n"
     ]
    }
   ],
   "source": [
    "#refer paper\n",
    "C = 1 # greater than 2\n",
    "beta = 0.5 # belongs to [0,1]\n",
    "\n",
    "regret_trials_2 = []\n",
    "perc_optimal_trials_2 = []\n",
    "cum_regret_trials_2 = []\n",
    "for trial in range(trials):\n",
    "    \n",
    "    #Sample means and variances\n",
    "    sample_rewards = [[] for k in range(K)]\n",
    "    net_rewards = []\n",
    "    net_cv = 0\n",
    "    \n",
    "    #cvar values\n",
    "    cvs = [0]*K\n",
    "    #indices\n",
    "    Is = [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",
    "    #rounds count\n",
    "    rounds = 0\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",
    "        #Update arm played count\n",
    "        num_played[i] += 1   \n",
    "        \n",
    "        #Update cvar\n",
    "        cvs[i] = reward\n",
    "        if i == 0:\n",
    "            net_cv = reward\n",
    "        else:   \n",
    "            net_rewards.sort()\n",
    "            net_cv = cvar_compute(net_rewards)\n",
    "        \n",
    "        #Update regret        \n",
    "        cum_regret_till_now += cv_best - true_cvs[i]\n",
    "        regret_till_now = cv_best - net_cv\n",
    "        regret.append(regret_till_now)\n",
    "        cum_regret.append(cum_regret_till_now)\n",
    "        perc_optimal.append(num_played[best_arm]) \n",
    "        \n",
    "    \n",
    "    for i in range(K, n):\n",
    "        #indices\n",
    "        Is = [cv + sqrt(11*(C*np.log(i) + beta*np.log(3))/(epsilon*num)) for cv, num in zip(cvs, num_played)]\n",
    "        arm_to_pull = np.argmax(Is)\n",
    "        \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 cvar\n",
    "        sample_rewards[arm_to_pull].sort()\n",
    "        net_rewards.sort()\n",
    "        cvs[arm_to_pull] = cvar_compute(sample_rewards[arm_to_pull])        \n",
    "        net_cv = cvar_compute(net_rewards)\n",
    "        \n",
    "        #Update regret\n",
    "        regret_till_now = cv_best - net_cv\n",
    "        cum_regret_till_now += cv_best - true_cvs[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(i))\n",
    "    \n",
    "    regret_trials_2.append(regret)\n",
    "    perc_optimal_trials_2.append(perc_optimal)\n",
    "    cum_regret_trials_2.append(cum_regret)\n",
    "    \n",
    "regret_avg_2 = np.mean(np.array(regret_trials_2), axis = 0)\n",
    "perc_optimal_avg_2 = np.mean(np.array(perc_optimal_trials_2), axis = 0)\n",
    "cum_regret_avg_2 = np.mean(np.array(cum_regret_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(cvs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### cVaR-ETC (New)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Regret', 0.6570885247632989)\n",
      "('Cumulative Regret', 582.6713203471872)\n",
      "('Perc optimal', 0.47750000000000004)\n",
      "[15, 940, 15, 15, 15]\n",
      "[-0.40184644117153967, 0.6793479236774999, 1.3747923040081491, -0.6862796315104638, -2.2830562414087097]\n"
     ]
    }
   ],
   "source": [
    "tau = 15\n",
    "\n",
    "regret_trials_3 = []\n",
    "cum_regret_trials_3 = []\n",
    "perc_optimal_trials_3 = []\n",
    "for trial in range(trials):\n",
    "    \n",
    "    #Sample means and variances\n",
    "    sample_rewards = [[] for k in range(K)]\n",
    "    net_rewards = []\n",
    "    net_cv = 0\n",
    "    #mean-variance values\n",
    "    cvs = [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",
    "            #Update arm played count\n",
    "            num_played[i] += 1   \n",
    "            \n",
    "            #Update CV\n",
    "            if j == 0:\n",
    "                cvs[i] = reward\n",
    "            else:\n",
    "                sample_rewards[i].sort()\n",
    "                cvs[i] = float(sum(sample_rewards[i][:int(np.ceil(len(sample_rewards[i])*epsilon))]\\\n",
    "                          ))/np.ceil(len(sample_rewards[i])*epsilon)\n",
    "            if i == 0 and j == 0: \n",
    "                net_cv = reward\n",
    "            else:\n",
    "                net_rewards.sort()            \n",
    "                net_cv = float(sum(net_rewards[:int(np.ceil(len(net_rewards)*epsilon))]\\\n",
    "                          ))/np.ceil(len(net_rewards)*epsilon)\n",
    "            \n",
    "            #Update regret\n",
    "            regret_till_now = cv_best - net_cv\n",
    "            cum_regret_till_now += cv_best - true_cvs[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(cvs)\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",
    "        num_played[exploit_arm] += 1\n",
    "        #Update CV\n",
    "        sample_rewards[exploit_arm].sort()\n",
    "        net_rewards.sort()\n",
    "        cvs[exploit_arm] = float(sum(sample_rewards[exploit_arm][:int(np.ceil(len(sample_rewards[exploit_arm])*epsilon))]\\\n",
    "                          ))/np.ceil(len(sample_rewards[exploit_arm])*epsilon)\n",
    "        net_cv = float(sum(net_rewards[:int(np.ceil(len(net_rewards)*epsilon))]\\\n",
    "                          ))/np.ceil(len(net_rewards)*epsilon)\n",
    "        \n",
    "        #Update regret\n",
    "        regret_till_now = cv_best - net_cv\n",
    "        cum_regret_till_now += cv_best - true_cvs[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_3.append(regret)\n",
    "    cum_regret_trials_3.append(cum_regret)\n",
    "    perc_optimal_trials_3.append(perc_optimal)  \n",
    "\n",
    "regret_avg_3 = np.mean(np.array(regret_trials_3), axis = 0)\n",
    "cum_regret_avg_3 = np.mean(np.array(cum_regret_trials_3), axis = 0)\n",
    "perc_optimal_avg_3 = np.mean(np.array(perc_optimal_trials_3), axis = 0)\n",
    "print(\"Regret\", regret_avg_3[-1])\n",
    "print(\"Cumulative Regret\", cum_regret_avg_3[-1])\n",
    "print(\"Perc optimal\", perc_optimal_avg_3[-1])\n",
    "print(num_played)  #of the last trial\n",
    "print(cvs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02ae0849d0>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02ae084fd0>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02ae0d0450>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02ae0d0810>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'n')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'regret')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f02ae084f10>"
      ]
     },
     "execution_count": 104,
     "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 0x7f02ae01abd0>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02ae0270d0>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02ae0276d0>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02ae027190>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'n')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'perc of times optimal arm was played')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f02ae027790>"
      ]
     },
     "execution_count": 104,
     "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 0x7f02adfaf9d0>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02adf39050>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02adf394d0>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f02adf39810>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'n')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'cum regret')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f02adf39c50>"
      ]
     },
     "execution_count": 104,
     "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 = \"MARAB\")\n",
    "plt.plot(regret_avg_2 , color = \"green\", label = \"MARABOUT\")\n",
    "plt.plot(regret_avg_3 , color = \"red\", label = \"cVaR-ETC\")\n",
    "plt.xlabel('n')\n",
    "plt.ylabel('regret')\n",
    "plt.legend()\n",
    "if save == True:\n",
    "    plt.savefig('cvar_' + 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 = \"MARAB\")\n",
    "plt.plot(perc_optimal_avg_2 , color = \"green\", label = \"MARABOUT\")\n",
    "plt.plot(perc_optimal_avg_3 , color = \"red\", label = \"cVaR-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('cvar_' + problem_id + '_perc.png')\n",
    "plt.show()\n",
    "\n",
    "#Regret: shr\n",
    "plt.plot(cum_regret_avg_0 , color = \"yellow\", label = \"UCB\")\n",
    "plt.plot(cum_regret_avg_1, color = \"blue\", label = \"MARAB\")\n",
    "plt.plot(cum_regret_avg_2, color = \"green\", label = \"MARABOUT\")\n",
    "plt.plot(cum_regret_avg_3 , color = \"red\", label = \"cVaR-ETC\")\n",
    "plt.xlabel('n')\n",
    "plt.ylabel('cum regret')\n",
    "plt.legend()\n",
    "if save == True:\n",
    "    plt.savefig('cvar_' + 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
}