Multi-armed Bandits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementation of ε-Greedy, UCB, LinUCB, Contextual Bandits and Kernel UCB; Multi-armed Bandits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do not edit. These are the only imports permitted.\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from numpy.linalg import inv\n",
    "import matplotlib.pyplot as plt\n",
    "from abc import ABC, abstractmethod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Implement ε-Greedy and UCB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MAB(ABC):\n",
    "    \n",
    "    @abstractmethod\n",
    "    def play(self, tround, context):\n",
    "        # Current round of t (for my implementations average mean reward array \n",
    "        # at round t is passed to this function instead of tround itself)\n",
    "        self.tround = tround\n",
    "        # Context: features of contextual bandits\n",
    "        self.context = context\n",
    "        # choose an arm which yields maximum value of average mean reward, tie breaking randomly\n",
    "        chosen_arm = np.random.choice(np.where(self.tround==max(self.tround))[0])\n",
    "        return chosen_arm\n",
    "        pass\n",
    "        \n",
    "    \n",
    "    @abstractmethod\n",
    "    def update(self, arm, reward, context):\n",
    "        # get the chosen arm\n",
    "        self.arm = arm\n",
    "        # get the context (may be None)\n",
    "        self.context = context\n",
    "        # update the overall step of the model\n",
    "        self.step_n += 1\n",
    "        # update the step of individual arms\n",
    "        self.step_arm[self.arm] += 1\n",
    "        # update average mean reward of each arm\n",
    "        self.AM_reward[self.arm] = ((self.step_arm[self.arm] - 1) / float(self.step_arm[self.arm]) \n",
    "        * self.AM_reward[self.arm] + (1 / float(self.step_arm[self.arm])) * reward)\n",
    "        return\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EpsGreedy(MAB):\n",
    "    \n",
    "    def __init__(self, narms, epsilon, Q0=np.inf):\n",
    "        # Set number of arms\n",
    "        self.narms = narms\n",
    "        # Exploration probability\n",
    "        self.epsilon = epsilon\n",
    "        # Q0 values\n",
    "        self.Q0 = np.ones(self.narms)*np.inf\n",
    "        # Total step count\n",
    "        self.step_n = 0\n",
    "        # Step count for each arm\n",
    "        self.step_arm = np.zeros(self.narms)\n",
    "        # Mean reward for each arm\n",
    "        self.AM_reward = np.zeros(self.narms)\n",
    "        super().__init__()\n",
    "        return\n",
    "        \n",
    "    # Play one round and return the action (chosen arm)\n",
    "    def play(self, tround, context=None):\n",
    "        # Generate random number\n",
    "        p = np.random.rand()\n",
    "        \n",
    "        if self.epsilon == 0 and self.step_n == 0:\n",
    "            action = np.random.choice(self.narms)\n",
    "        elif p < self.epsilon:\n",
    "            action = np.random.choice(self.narms)\n",
    "        else:\n",
    "            # Q0 values are initially set to np.inf. Hence, choose an arm with maximum Q0 value (\n",
    "            # for all of them is np.inf, and therefore will play all of the arms at least one time)\n",
    "\n",
    "            if len(np.where(self.Q0==0)[0])<10:\n",
    "                # choose an arm with maximum Q0 value\n",
    "                action = np.random.choice(np.where(self.Q0==max(self.Q0))[0])\n",
    "                # after the arm is chosen, set the corresponding Q0 value to zero\n",
    "                self.Q0[action]=0\n",
    "            else:\n",
    "                # Now, after that we ensure that there is no np.inf in Q0 values and all of them are set to zero\n",
    "                # we return to play based on average mean rewards\n",
    "                action = super(EpsGreedy, self).play(self.AM_reward, context)\n",
    "        # np.argmax returns values 0-9, we want to compare with arm indices in dataset which are 1-10\n",
    "        # Hence, add 1 to action before returning\n",
    "        return action+1\n",
    "    \n",
    "        \n",
    "    def update(self, arm, reward, context=None):\n",
    "        super(EpsGreedy, self).update(arm, reward, context)\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UCB(MAB):\n",
    "    \n",
    "    def __init__(self, narms, rho, Q0=np.inf):\n",
    "        # Set number of arms\n",
    "        self.narms = narms\n",
    "        # Rho\n",
    "        self.rho = rho\n",
    "        # Q0 values\n",
    "        self.Q0 = np.ones(self.narms)*np.inf\n",
    "        # Total step count\n",
    "        self.step_n = 0\n",
    "        # Step count for each arm\n",
    "        self.step_arm = np.zeros(self.narms)\n",
    "        # Mean reward for each arm\n",
    "        self.AM_reward = np.zeros(self.narms)\n",
    "        super().__init__()\n",
    "        return\n",
    "\n",
    "    # Play one round and return the action (chosen arm)\n",
    "    def play(self, tround, context=None):\n",
    "        # Q0 values are initially set to np.inf. Hence, choose an arm with maximum Q0 value (\n",
    "        # for all of them is np.inf, and therefore will play all of the arms at least one time)\n",
    "            \n",
    "        if len(np.where(self.Q0==0)[0])<10:\n",
    "            # choose an arm with maximum Q0 value\n",
    "            action = np.random.choice(np.where(self.Q0==max(self.Q0))[0])\n",
    "            # after the arm is chosen, set the corresponding Q0 value to zero\n",
    "            self.Q0[action]=0\n",
    "        else:\n",
    "            # Now, after that we ensure that there is no np.inf in Q0 values and all of them are set to zero\n",
    "            # we return to play based on average mean rewards\n",
    "            \n",
    "            # construct UCB values which performs the sqrt part\n",
    "            ucb_values = np.zeros(self.narms)\n",
    "            for arm in range(self.narms):\n",
    "                if self.step_arm[arm]>0:\n",
    "                    ucb_values[arm]= np.sqrt(self.rho *(np.log(self.step_n)) / self.step_arm[arm])\n",
    "            action = super(UCB, self).play(self.AM_reward + ucb_values, context)\n",
    "        # np.argmax returns values 0-9, we want to compare with arm indices in dataset which are 1-10\n",
    "        # Hence, add 1 to action before returning     \n",
    "        return action+1\n",
    "        \n",
    "        \n",
    "    def update(self, arm, reward, context=None):\n",
    "        super(UCB, self).update(arm, reward, context)\n",
    "        return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Off-Policy Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def offlineEvaluate(mab, arms, rewards, contexts, nrounds=None):\n",
    "    # array to contain chosen arms in offline mode\n",
    "    chosen_arms = np.zeros(nrounds)\n",
    "    # rewards of each chosen arm\n",
    "    reward_arms = np.zeros(nrounds)\n",
    "    # cumulative reward at each iteration\n",
    "    cumulative_reward = np.zeros(nrounds)\n",
    "    # initialize tround to zero\n",
    "    T = 0\n",
    "    # initialize overall cumulative reward to zero\n",
    "    G = 0\n",
    "    # History or memory of offline evaluator\n",
    "    history = []\n",
    "    # play once and get the initial action\n",
    "    action = mab.play(T, contexts[0,:])\n",
    "    \n",
    "    #===============================\n",
    "    #    MAIN LOOP ...\n",
    "    #===============================\n",
    "    for i in range(np.shape(data)[0]):\n",
    "        action = mab.play(T, contexts[i,:])\n",
    "        if T<nrounds:\n",
    "            # update parameters and play only when chosen arm from bandit matches data\n",
    "            if action == arms[i]:\n",
    "                # append the current context of chosen arm to the previous history (list)\n",
    "                history.append(contexts[i,:])\n",
    "                # get the reward of chosen arm at round T\n",
    "                reward_arms[T] = rewards[i]\n",
    "                # the returned action is between 1-10, setting to python encoding ==> 0-9\n",
    "                mab.update(action-1, rewards[i], contexts[i,:])\n",
    "                # update overall cumulative reward\n",
    "                G += rewards[i]\n",
    "                # update cumulative reward of round T \n",
    "                cumulative_reward[T] = G\n",
    "                # store chosen arm at round T\n",
    "                chosen_arms[T] = action\n",
    "                T +=1\n",
    "        else:\n",
    "            # if desired tround ends, terminate the loop\n",
    "            break\n",
    "    return reward_arms, chosen_arms, cumulative_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EpsGreedy average reward 0.185\n"
     ]
    }
   ],
   "source": [
    "# load dataset and initialize arms, rewards and contexts arrays\n",
    "data = np.loadtxt('./dataset.txt')\n",
    "arms = data[:,0]\n",
    "rewards = data[:,1]\n",
    "contexts = data[:,2:102]\n",
    "mab = EpsGreedy(10, 0.05)\n",
    "results_EpsGreedy, chosen_arms_EpsGreedy, cumulative_reward_EpsGreedy = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('EpsGreedy average reward', np.mean(results_EpsGreedy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UCB average reward 0.14625\n"
     ]
    }
   ],
   "source": [
    "mab = UCB(10, 1.0)\n",
    "results_UCB, chosen_arms_UCB, cumulative_reward_UCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('UCB average reward', np.mean(results_UCB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Contextual Bandits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinUCB(MAB):\n",
    "    \n",
    "    def __init__(self, narms, ndims, alpha):\n",
    "        # Set number of arms\n",
    "        self.narms = narms\n",
    "        # Number of context features\n",
    "        self.ndims = ndims\n",
    "        # explore-exploit parameter\n",
    "        self.alpha = alpha\n",
    "        # Instantiate A as a ndims×ndims matrix for each arm\n",
    "        self.A = np.zeros((self.narms, self.ndims, self.ndims))\n",
    "        # Instantiate b as a 0 vector of length ndims.\n",
    "        self.b = np.zeros((narms, self.ndims, 1))\n",
    "        # set each A per arm as identity matrix of size ndims\n",
    "        for arm in range(self.narms):\n",
    "            self.A[arm] = np.eye(self.ndims)\n",
    "        \n",
    "        super().__init__()\n",
    "        return\n",
    "        \n",
    "    def play(self, tround, context):\n",
    "        # gains per each arm\n",
    "        p_t = np.zeros(self.ndims)\n",
    "        \n",
    "        #===============================\n",
    "        #    MAIN LOOP ...\n",
    "        #===============================\n",
    "        for i in range(self.ndims):\n",
    "            # initialize theta hat\n",
    "            self.theta = inv(self.A[i]).dot(self.b[i])\n",
    "            # get context of each arm from flattened vector of length 100\n",
    "            cntx = context[i*10:(i+1)*10]\n",
    "            # get gain reward of each arm\n",
    "            p_t[i] = self.theta.T.dot(cntx\n",
    "                ) + self.alpha * np.sqrt(\n",
    "            cntx.dot(inv(self.A[i]).dot(cntx)))\n",
    "        action = np.random.choice(np.where(p_t==max(p_t))[0])\n",
    "        # np.argmax returns values 0-9, we want to compare with arm indices in dataset which are 1-10\n",
    "        # Hence, add 1 to action before returning\n",
    "        return action+1\n",
    "        \n",
    "    \n",
    "    def update(self, arm, reward, context):\n",
    "        self.A[arm] = self.A[arm] + np.outer(context[arm*10:(arm+1)*10],context[arm*10:(arm+1)*10])\n",
    "        self.b[arm] = np.add(self.b[arm].T, context[arm*10:(arm+1)*10]*reward).reshape(self.ndims,1)\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinUCB average reward 0.53\n"
     ]
    }
   ],
   "source": [
    "mab = LinUCB(10, 10, 1.0)\n",
    "results_LinUCB, chosen_arms_LinUCB, cumulative_reward_LinUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('LinUCB average reward', np.mean(results_LinUCB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Evaluation\n",
    "### 4.A.\n",
    "In order to evaluate models and plot the running per-round cumulative reward per round, I propose to run each model 1000 times (except LinUCB which yields same reward per specific alpha value), and then get average of these rounds as plot. However, I have implemented only one simulation first and have showed the results. Here we go ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EpsGreedy average reward 0.2475\n",
      "UCB average reward 0.1525\n",
      "LinUCB average reward 0.53\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "                                #===============================\n",
    "                                #    single simulation ...\n",
    "                                #===============================\n",
    "\n",
    "#===============================\n",
    "#    Epsilon Greedy ...\n",
    "#===============================\n",
    "mab = EpsGreedy(10, 0.05)\n",
    "results_EpsGreedy, chosen_arms_EpsGreedy, cumulative_reward_EpsGreedy = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('EpsGreedy average reward', np.mean(results_EpsGreedy))\n",
    "\n",
    "#===============================\n",
    "#    UCB ...\n",
    "#===============================\n",
    "mab = UCB(10, 1.0)\n",
    "results_UCB, chosen_arms_UCB, cumulative_reward_UCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('UCB average reward', np.mean(results_UCB))\n",
    "\n",
    "#===============================\n",
    "#    Linear UCB (Contextual) ...\n",
    "#===============================\n",
    "mab = LinUCB(10, 10, 1.0)\n",
    "results_LinUCB, chosen_arms_LinUCB, cumulative_reward_LinUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('LinUCB average reward', np.mean(results_LinUCB))\n",
    "\n",
    "#===============================\n",
    "#    Plotting results ...\n",
    "#===============================\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(cumulative_reward_LinUCB/np.linspace(1,800,800), label = r\"$\\alpha=1$ (LinUCB)\")\n",
    "plt.plot(cumulative_reward_UCB/(np.linspace(1,800,800)), label = r\"$\\rho=1$ (UCB)\")\n",
    "plt.plot(cumulative_reward_EpsGreedy/(np.linspace(1,800,800)), label = r\"$\\epsilon=0.05$ (greedy)\")\n",
    "plt.legend(bbox_to_anchor=(1.2, 0.5))\n",
    "plt.xlabel(\"Rounds\")\n",
    "plt.ylabel(r\"$T^{-1}\\sum_{t=1}^T\\ r_{t,a}$\", fontsize='large')\n",
    "plt.title(\"Per-round Cumulative Rewards after single simulation\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EpsGreedy average reward 0.22032875000000005\n",
      "UCB average reward 0.18377749999999998\n",
      "LinUCB average reward 0.53\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "                                #===============================\n",
    "                                #    1000 simulations ...\n",
    "                                #===============================\n",
    "\n",
    "#===============================\n",
    "#    Epsilon Greedy ...\n",
    "#===============================\n",
    "# aray to store cumulative reward of each round for 1000 runs\n",
    "mean_EPSgreedy = np.zeros(800)\n",
    "# aray to store average reward of each round for 1000 runs\n",
    "average_results = np.zeros(800)\n",
    "for i in range(1000):\n",
    "    mab = EpsGreedy(10, 0.05)\n",
    "    results_EpsGreedy, chosen_arms_EpsGreedy, cumulative_reward_EpsGreedy = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "    average_results += results_EpsGreedy\n",
    "    mean_EPSgreedy += cumulative_reward_EpsGreedy\n",
    "print('EpsGreedy average reward', np.mean(average_results/1000))\n",
    "\n",
    "#===============================\n",
    "#    UCB ...\n",
    "#===============================\n",
    "# aray to store cumulative reward of each round for 1000 runs\n",
    "mean_UCB = np.zeros(800)\n",
    "# aray to store average reward of each round for 1000 runs\n",
    "average_results = np.zeros(800)\n",
    "for i in range(1000):\n",
    "    mab = UCB(10, 1.0)\n",
    "    results_UCB, chosen_arms_UCB, cumulative_reward_UCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "    average_results += results_UCB\n",
    "    mean_UCB += cumulative_reward_UCB\n",
    "print('UCB average reward', np.mean(average_results/1000))\n",
    "\n",
    "#===============================\n",
    "#    Linear UCB (Contextual) ...\n",
    "#===============================\n",
    "mab = LinUCB(10, 10, 1.0)\n",
    "results_LinUCB, chosen_arms_LinUCB, cumulative_reward_LinUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('LinUCB average reward', np.mean(results_LinUCB))\n",
    "\n",
    "#===============================\n",
    "#    Plotting results ...\n",
    "#===============================\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(cumulative_reward_LinUCB/np.linspace(1,800,800), label = r\"$\\alpha=1$ (LinUCB)\")\n",
    "plt.plot(mean_UCB/(1000*np.linspace(1,800,800)), label = r\"$\\rho=1$ (UCB)\")\n",
    "plt.plot(mean_EPSgreedy/(1000*np.linspace(1,800,800)), label = r\"$\\epsilon=0.05$ (greedy)\")\n",
    "plt.legend(bbox_to_anchor=(1.2, 0.5))\n",
    "plt.xlabel(\"Rounds\")\n",
    "plt.ylabel(r\"$T^{-1}\\sum_{t=1}^T\\ r_{t,a}$\", fontsize='large')\n",
    "plt.title(\"Per-round Cumulative Rewards after 1000 simulations\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.B.\n",
    "To obtain the optimal value of alpha regarding Linear UCB implementation, I propose to define a range of values for alpha, then implementing LinUCB per each of the alpha values, and finally find the argument of alpha which yields maximum reward. I will use offline evaluation mode for my implementations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best value of alpha resulting in maximum average reward is:  0.02\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# array of different alpha values ranging from 0 to 5 (excluding 0 itself because alpha is member of R+) with step of .01\n",
    "alphas = np.linspace(0,5,501)[1:]\n",
    "# average reward of LinUCB per each alpha value\n",
    "average_results = np.zeros(len(alphas))\n",
    "\n",
    "#===============================\n",
    "#    Looping alphas ...\n",
    "#===============================\n",
    "for alpha in range(len(alphas)):    \n",
    "    mab = LinUCB(10, 10, alphas[alpha])\n",
    "    results_LinUCB, chosen_arms_LinUCB, cumulative_reward_LinUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "    average_results[alpha] = np.mean(results_LinUCB)\n",
    "print('Best value of alpha resulting in maximum average reward is: ', alphas[np.argmax(average_results)])\n",
    "#===============================\n",
    "#    Plotting ...\n",
    "#===============================\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(alphas, average_results, label = \"$alpha=x.xx$ (LinUCB)\")\n",
    "plt.legend(bbox_to_anchor=(1.2, 0.5))\n",
    "plt.xlabel(\"Alpha values\")\n",
    "plt.ylabel(\"Average Reward\")\n",
    "plt.title(\"Search strategy to optimize alpha value as hyper-parameter\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Re-plotting e-Greedy, UCB & LinUCB\n",
    "After the best value for alpha is obtained, I wish to plot evaluation of Linear UCB with new value of alpha = 0.02.\n",
    "The previous results are overlayed for comparison purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean reward of LinUCB with alpha = 0.02 is:  0.73125\n",
      "Mean reward of LinUCB with alpha = 1 is:  0.53\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# build LinUCB with alpha = 0.02\n",
    "mab = LinUCB(10, 10, 0.02)\n",
    "results_LinUCB_02, chosen_arms_LinUCB_02, cumulative_reward_LinUCB_02 = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('Mean reward of LinUCB with alpha = 0.02 is: ', np.mean(results_LinUCB_02))\n",
    "\n",
    "# build LinUCB with alpha = 1\n",
    "mab = LinUCB(10, 10, 1)\n",
    "results_LinUCB_1, chosen_arms_LinUCB_1, cumulative_reward_LinUCB_1 = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('Mean reward of LinUCB with alpha = 1 is: ', np.mean(results_LinUCB_1))\n",
    "\n",
    "#===============================\n",
    "#    Plotting results ...\n",
    "#===============================\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(cumulative_reward_LinUCB_02/np.linspace(1,800,800), label = r\"$\\alpha=0.02$ (LinUCB)\")\n",
    "plt.plot(cumulative_reward_LinUCB_1/np.linspace(1,800,800), label = r\"$\\alpha=1$ (LinUCB)\")\n",
    "plt.plot(mean_UCB/(1000*np.linspace(1,800,800)), label = r\"$\\rho=1$ (UCB)\")\n",
    "plt.plot(mean_EPSgreedy/(1000*np.linspace(1,800,800)), label = r\"$\\epsilon=0.05$ (greedy)\")\n",
    "plt.legend(bbox_to_anchor=(1.2, 0.5))\n",
    "plt.xlabel(\"Rounds\")\n",
    "plt.ylabel(r\"$T^{-1}\\sum_{t=1}^T\\ r_{t,a}$\", fontsize='large')\n",
    "plt.title(\"Per-round Cumulative Rewards after 1000 simulations \" + r\"($\\epsilon$-greedy & UCB ONLY)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. KernelUCB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do not edit. Special import for this section.\n",
    "from sklearn.metrics.pairwise import rbf_kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KernelUCB(MAB):\n",
    "    \n",
    "    def __init__(self, narms, ndims, gamma, eta, kern):\n",
    "        # Set number of arms\n",
    "        self.narms = narms\n",
    "        # Number of context features\n",
    "        self.ndims = ndims\n",
    "        # regularization parameter\n",
    "        self.eta = eta\n",
    "        # exploration parameter\n",
    "        self.gamma = gamma\n",
    "        # kernel function\n",
    "        self.kern = kern\n",
    "        # u_n_t values\n",
    "        self.u = np.zeros(self.narms)\n",
    "        # sigma_n_t values\n",
    "        self.sigma = np.zeros(self.narms)\n",
    "        # list of contexts of chosen actions to the moment\n",
    "        self.pulled = []\n",
    "        # list of rewards corresponding to chosen actions to the moment\n",
    "        self.rewards = []\n",
    "        # define a dictionary to store kernel matrix inverse in each tround\n",
    "        self.Kinv = {}\n",
    "        super().__init__()\n",
    "        return\n",
    "        \n",
    "    def play(self, tround, context):\n",
    "        self.tround = tround\n",
    "        # get the flattened context and reshape it to an array of shape (narms,ndims)\n",
    "        context = np.reshape(context, (self.narms,self.ndims))\n",
    "        \n",
    "        if self.tround == 0:\n",
    "            # playing action 1 for first round and setting u_0[0] to 1.0\n",
    "            self.u[0] = 1.0\n",
    "        else:\n",
    "            \n",
    "            #========================================\n",
    "            #    Calculating all possible k_x ...\n",
    "            #========================================\n",
    "        \n",
    "            # To perform kernel UCB in the least and efficient time as possible I propose to\n",
    "            # calculate k_x for all of the contexts and not just for chosen context (x_t)\n",
    "            # this will be hugely beneficiary to calculating sigma_n_t step in for loop\n",
    "        \n",
    "            # calculate the kernel between each of the contexts of narms and the pulled \n",
    "            # contexts of chosen arms to the moment\n",
    "        \n",
    "            # self.pulled is just a list of arrays, and hence reshaping it to a valid\n",
    "            # numpy array of shape (tround+1,ndims). Since tround is starting from zero\n",
    "            # it is being added by 1 to give valid shape in each round especially for\n",
    "            # the first round\n",
    "            \n",
    "            k_x = self.kern(context,np.reshape(self.pulled,(self.tround,self.ndims)))\n",
    "            \n",
    "            #===============================\n",
    "            #    MAIN LOOP ...\n",
    "            #===============================\n",
    "            \n",
    "            for i in range(self.narms):\n",
    "                self.sigma[i] = np.sqrt(self.kern(context[i].reshape(1,-1),context[i].reshape(1,-1))-k_x[i].T.dot(self.Kinv[self.tround-1]).dot(k_x[i]))  \n",
    "                self.u[i] = k_x[i].T.dot(self.Kinv[self.tround-1]).dot(self.y) + (self.eta/np.sqrt(self.gamma))*self.sigma[i]\n",
    "            \n",
    "        # tie breaking arbitrarily\n",
    "        action = np.random.choice(np.where(self.u==max(self.u))[0])\n",
    "        # np.argmax returns values 0-9, we want to compare with arm indices in dataset which are 1-10\n",
    "        # Hence, add 1 to action before returning\n",
    "        return action+1\n",
    "        \n",
    "    \n",
    "    def update(self, arm, reward, context):\n",
    "        # get the flattened context and reshape it to an array of shape (narms,ndims)\n",
    "        context = np.reshape(context, (self.narms,self.ndims))\n",
    "        # append the context of choesn arm (index = [arm]) with the previous list of contexts (self.pulled)\n",
    "        # the obserbved context is being reshaped into a column vector simultanesously for future kernel calculations\n",
    "        self.pulled.append(context[arm].reshape(1,-1))\n",
    "        # set currently observed context of chosen arm as x_t\n",
    "        x_t = context[arm].reshape(1,-1)\n",
    "        \n",
    "        #========================================\n",
    "        #    Calculating all possible k_x ...\n",
    "        #========================================\n",
    "        \n",
    "        # To perform kernel UCB in the least and efficient time as possible I propose to\n",
    "        # calculate k_x for all of the contexts and not just for chosen context (x_t)\n",
    "        # this will be hugely beneficiary to calculating sigma_n_t step in for loop\n",
    "        \n",
    "        # calculate the kernel between each of the contexts of narms and the pulled \n",
    "        # contexts of chosen arms to the moment\n",
    "        \n",
    "        # self.pulled is just a list of arrays, and hence reshaping it to a valid\n",
    "        # numpy array of shape (tround+1,ndims). Since tround is starting from zero\n",
    "        # it is being added by 1 to give valid shape in each round especially for\n",
    "        # the first round\n",
    "        k_x = self.kern(context,np.reshape(self.pulled,(self.tround+1,self.ndims)))\n",
    "        \n",
    "        # append the observed reward value of chosen action to the previous list of rewards\n",
    "        self.rewards.append(reward)\n",
    "        # generate array of y. Since tround is starting from zero\n",
    "        # it is being added by 1 to give valid shape in each round especially for\n",
    "        # the first round\n",
    "        self.y = np.reshape(self.rewards,(self.tround+1,1))\n",
    "        \n",
    "        # building inverse of kernel matrix for first round is different from consequent rounds.\n",
    "        if self.tround==0:\n",
    "            self.Kinv[self.tround] = 1.0/(self.kern(x_t,x_t) + self.gamma)\n",
    "        else:\n",
    "            # set inverse of kernel matrix as the kernel matrix inverse of the previous round\n",
    "            Kinv = self.Kinv[self.tround-1]\n",
    "            # set b as k_(x_t) excluding the kernel value of the current round\n",
    "            b = k_x[arm][:-1]\n",
    "            # reshape b into the valid numpy column vector\n",
    "            b = b.reshape(self.tround,1)\n",
    "            # compute b.T.dot(kernel matrix inverse)\n",
    "            bKinv = np.dot(b.T,Kinv)\n",
    "            # compute (kernel matrix inverse).dot(b)\n",
    "            Kinvb = np.dot(Kinv,b)\n",
    "            \n",
    "            #==========================================================================\n",
    "            #    Calculating components of current Kernel matrix inverse (Kinv_tround)\n",
    "            #==========================================================================\n",
    "            \n",
    "            K22 = 1.0/(k_x[arm][-1] + self.gamma - np.dot(bKinv,b))            \n",
    "            K11 = Kinv + K22*np.dot(Kinvb,bKinv)\n",
    "            K12 = -K22*Kinvb\n",
    "            K21 = -K22*bKinv\n",
    "            K11 = np.reshape(K11,(self.tround,self.tround))\n",
    "            K12 = np.reshape(K12,(self.tround,1))\n",
    "            K21 = np.reshape(K21,(1,self.tround))\n",
    "            K22 = np.reshape(K22,(1,1))\n",
    "            # stack components into an array of shape(self.tround, self.tround)\n",
    "            self.Kinv[self.tround] = np.vstack((np.hstack((K11,K12)),np.hstack((K21,K22)))) \n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KernelUCB average reward 0.57375\n"
     ]
    }
   ],
   "source": [
    "mab = KernelUCB(10, 10, 1.0, 1.0, rbf_kernel)\n",
    "results_KernelUCB, chosen_arms_KernelUCB, cumulative_reward_KernelUCB = offlineEvaluate(mab, arms, rewards, contexts,800)\n",
    "print('KernelUCB average reward', np.mean(results_KernelUCB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performing grid search\n",
    "Kernel UCB comes with two hyper-parameters including Gamma and Eta. To optimize these hyper-parameters, I propose to perform a grid search as follows, where the values of gamma will range between 0 and 10 excluding 0, and values of etas will range between 0 and +2. The results will be shown on a grid along with colorbar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum average reward is:  0.7625\n",
      "\n",
      "\n",
      "Listing all possible pairs of gammas and etas yielding maximum average reward in Kernel UCB:\n",
      "\n",
      "\n",
      "░░ ▒ ▒ █ █ List of Values █ █ ▒ ▒ ░░\n",
      "Gamma: \t Eta:\n",
      "1.0 \t 0.6000000000000001\n",
      "2.5 \t 0.9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x792 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# arrange eta values as hyper-parameter between 0 and +2 with step of 0.1\n",
    "etas = np.linspace(0,2,21)\n",
    "# arrange gamma values as hyper-parameter between 0 and 10 with step of 0.5 excluding 0\n",
    "gammas = np.linspace(0,10,21)[1:]\n",
    "# main array to contain average reward of Kernel UCB given eta and gamma values\n",
    "avg = np.zeros((len(etas),len(gammas)))\n",
    "\n",
    "#===============================\n",
    "#    Loop etas & gammas ...\n",
    "#===============================\n",
    "\n",
    "for i in range(len(etas)):\n",
    "    for j in range(len(gammas)):\n",
    "        mab = KernelUCB(10, 10, gammas[j], etas[i], rbf_kernel)\n",
    "        results_KernelUCB, chosen_arms_KernelUCB, cumulative_reward_KernelUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "        avg[i][j] = np.mean(results_KernelUCB)\n",
    "\n",
    "# printing the maximum average reward achieved \n",
    "print('The maximum average reward is: ', np.max(avg))\n",
    "\n",
    "# printing list of all possible pairs of gamma and eta resulting in maximum average reward\n",
    "pairs = np.where(avg==np.max(avg))\n",
    "print('\\n')\n",
    "print('Listing all possible pairs of gammas and etas yielding maximum average reward in Kernel UCB:')\n",
    "print('\\n')\n",
    "print('░░ ▒ ▒ █ █ List of Values █ █ ▒ ▒ ░░')\n",
    "print('Gamma:', '\\t', 'Eta:')\n",
    "for pair in range(len(pairs[0])):\n",
    "    print(gammas[pairs[1][pair]], '\\t', etas[pairs[0][pair]])\n",
    "\n",
    "#===============================\n",
    "#    Plotting results ...\n",
    "#===============================\n",
    "\n",
    "plt.figure(figsize=(15, 11))\n",
    "plt.subplots_adjust(left=.05, right=1.2, bottom=0.05, top=1.2)\n",
    "plt.imshow(avg, interpolation='nearest', cmap=plt.cm.hot)\n",
    "plt.xlabel('gammas')\n",
    "plt.ylabel('etas')\n",
    "plt.colorbar()\n",
    "plt.xticks(np.arange(len(gammas)), gammas)\n",
    "plt.yticks(np.arange(len(etas)), etas)\n",
    "plt.title('Grid Search Average Reward Value')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing Kernel UCB with other kernels\n",
    "Here I purpose to run Kernel UCB with chi square kernel. Hence, I will import chi2 kernel from sklearn. I will re-run the grid search for this kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import chi square kernel\n",
    "from sklearn.metrics.pairwise import chi2_kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum average reward is:  0.79\n",
      "\n",
      "\n",
      "Listing all possible pairs of gammas and etas yielding maximum average reward in Kernel UCB:\n",
      "\n",
      "\n",
      "░░ ▒ ▒ █ █ List of Values █ █ ▒ ▒ ░░\n",
      "Gamma: \t Eta:\n",
      "4.5 \t 1.4000000000000001\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x792 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# arrange eta values as hyper-parameter between 0 and +2 with step of 0.1\n",
    "etas = np.linspace(0,2,21)\n",
    "# arrange gamma values as hyper-parameter between 0 and 10 with step of 0.5 excluding 0\n",
    "gammas = np.linspace(0,10,21)[1:]\n",
    "# main array to contain average reward of Kernel UCB given eta and gamma values\n",
    "avg = np.zeros((len(etas),len(gammas)))\n",
    "\n",
    "#===============================\n",
    "#    Loop etas & gammas ...\n",
    "#===============================\n",
    "\n",
    "for i in range(len(etas)):\n",
    "    for j in range(len(gammas)):\n",
    "        mab = KernelUCB(10, 10, gammas[j], etas[i], chi2_kernel)\n",
    "        results_KernelUCB, chosen_arms_KernelUCB, cumulative_reward_KernelUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "        avg[i][j] = np.mean(results_KernelUCB)\n",
    "\n",
    "# printing the maximum average reward achieved \n",
    "print('The maximum average reward is: ', np.max(avg))\n",
    "\n",
    "# printing list of all possible pairs of gamma and eta resulting in maximum average reward\n",
    "pairs = np.where(avg==np.max(avg))\n",
    "print('\\n')\n",
    "print('Listing all possible pairs of gammas and etas yielding maximum average reward in Kernel UCB:')\n",
    "print('\\n')\n",
    "print('░░ ▒ ▒ █ █ List of Values █ █ ▒ ▒ ░░')\n",
    "print('Gamma:', '\\t', 'Eta:')\n",
    "for pair in range(len(pairs[0])):\n",
    "    print(gammas[pairs[1][pair]], '\\t', etas[pairs[0][pair]])\n",
    "\n",
    "#===============================\n",
    "#    Plotting results ...\n",
    "#===============================\n",
    "\n",
    "plt.figure(figsize=(15, 11))\n",
    "plt.subplots_adjust(left=.05, right=1.2, bottom=0.05, top=1.2)\n",
    "plt.imshow(avg, interpolation='nearest', cmap=plt.cm.hot)\n",
    "plt.xlabel('gammas')\n",
    "plt.ylabel('etas')\n",
    "plt.colorbar()\n",
    "plt.xticks(np.arange(len(gammas)), gammas)\n",
    "plt.yticks(np.arange(len(etas)), etas)\n",
    "plt.title('Grid Search Average Reward Value')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}