xinjiel2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# COMP90051 Project 2"
   ]
  },
  {
   "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. Implementing ε-Greedy and UCB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MAB(ABC):\n",
    "    \"\"\"\n",
    "    Abstract class that represents a multi-armed bandit (MAB)\n",
    "    \"\"\"\n",
    "    \n",
    "    @abstractmethod\n",
    "    def play(self, tround, context):\n",
    "        \"\"\"\n",
    "        Play a round\n",
    "        \n",
    "        Arguments\n",
    "        =========\n",
    "        tround : int\n",
    "            positive integer identifying the round\n",
    "        \n",
    "        context : 1D float array, shape (self.ndims * self.narms), optional\n",
    "            context given to the arms\n",
    "        \n",
    "        Returns\n",
    "        =======\n",
    "        arm : int\n",
    "            the positive integer arm id for this round\n",
    "        \"\"\"\n",
    "    \n",
    "    @abstractmethod\n",
    "    def update(self, arm, reward, context):\n",
    "        \"\"\"\n",
    "        Updates the internal state of the MAB after a play\n",
    "        \n",
    "        Arguments\n",
    "        =========\n",
    "        arm : int\n",
    "            a positive integer arm id in {1, ..., self.narms}\n",
    "        \n",
    "        reward : float\n",
    "            reward received from arm\n",
    "        \n",
    "        context : 1D float array, shape (self.ndims * self.narms), optional\n",
    "            context given to arms\n",
    "        \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EpsGreedy(MAB):\n",
    "    \"\"\"\n",
    "    Epsilon-Greedy multi-armed bandit\n",
    "\n",
    "    Arguments\n",
    "    =========\n",
    "    narms : int\n",
    "        number of arms\n",
    "\n",
    "    epsilon : float\n",
    "        explore probability\n",
    "\n",
    "    Q0 : float, optional\n",
    "        initial value for the arms\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, narms, epsilon, Q0=np.inf):\n",
    "        assert (narms > 0),\"narms must be positive integers\"\n",
    "        assert (type(epsilon)==float),\"epsilon must be floating number\"\n",
    "        \n",
    "        self.narms = narms\n",
    "        self.epsilon = epsilon\n",
    "        self.Q0 = Q0\n",
    "        self.arm_visit_count = {}\n",
    "        self.arm_total_reward = {}\n",
    "        \n",
    "        self.arm_with_Q = {}\n",
    "        for arm in range(1,self.narms+1):\n",
    "            self.arm_with_Q[arm]=self.Q0 #Initial all the arm with Q0\n",
    "            \n",
    "            self.arm_visit_count[arm]=0 #Initial all the arm with zero number of visits\n",
    "            self.arm_total_reward[arm] = 0 #Initial all the arm with zero reward\n",
    "            \n",
    "        \n",
    "    def play(self, tround, context=None):\n",
    "        assert (tround > 0),\"tround must be positive integers\"\n",
    "        if np.random.random() <self.epsilon: #exploration(Random select an arm)\n",
    "            action = np.random.choice(self.narms)\n",
    "        else:                               #Select the arm with highest Q value \n",
    "            #Getting the highest value from Q, then find the corresponding key and append them\n",
    "            highest = max(self.arm_with_Q.values())\n",
    "            highest_Qs = [key for key, value in self.arm_with_Q.items() if value == highest]\n",
    "            if len(highest_Qs)>1:\n",
    "                action = np.random.choice(highest_Qs)#Tie Breaker\n",
    "            else:\n",
    "                action = highest_Qs[0]\n",
    "         \n",
    "        return action\n",
    "        \n",
    "        \n",
    "    def update(self, arm, reward, context=None):\n",
    "        assert (arm > 0 and arm <=self.narms),\"arm must be positive integers and no larger than self.narms\"\n",
    "        assert (type(reward)==float or type(reward) == np.float64),\"reward must be floating point\"\n",
    "        self.arm_visit_count[arm] += 1\n",
    "        self.arm_total_reward[arm] += reward\n",
    "        updated_reward = self.arm_total_reward[arm]/self.arm_visit_count[arm]#From lecture 13 slide pg7 \n",
    "        \n",
    "        self.arm_with_Q.update({arm:updated_reward})\n",
    "        \n",
    "        return self.arm_with_Q\n",
    "        \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UCB(MAB):\n",
    "    \"\"\"\n",
    "    Upper Confidence Bound (UCB) multi-armed bandit\n",
    "\n",
    "    Arguments\n",
    "    =========\n",
    "    narms : int\n",
    "        number of arms\n",
    "\n",
    "    rho : float\n",
    "        positive real explore-exploit parameter\n",
    "\n",
    "    Q0 : float, optional\n",
    "        initial value for the arms\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, narms, rho, Q0=np.inf):\n",
    "        assert (narms > 0),\"narms must be positive integers\"\n",
    "        assert (type(rho)==float and rho >0.0 and np.isreal(rho)),\"rho must be positive real floating number\"\n",
    "        self.narms = narms\n",
    "        self.rho = rho\n",
    "        self.Q0 = Q0\n",
    "        self.arm_visit_count = {}\n",
    "        self.arm_total_reward = {}\n",
    "        \n",
    "        self.arm_with_avg_reward = {}\n",
    "        for arm in range(1,self.narms+1):\n",
    "            self.arm_with_avg_reward[arm]=self.Q0 #Initial all the arm with Q0\n",
    "            \n",
    "            self.arm_visit_count[arm]=0 #Initial all the arm with zero number of visits\n",
    "            self.arm_total_reward[arm] = 0  #Initial all the arm with zero reward\n",
    "        \n",
    "    \n",
    "    def play(self, tround, context=None):\n",
    "        assert (tround > 0),\"tround must be positive integers\"\n",
    "        #copy each arm with reward for later calculation at tround\n",
    "        temp_arm_with_Q = self.arm_with_avg_reward\n",
    "        \n",
    "        for arm in temp_arm_with_Q:\n",
    "            if self.arm_visit_count[arm] == 0: #Use Q0 for the first round\n",
    "                continue\n",
    "                \n",
    "                \n",
    "            else:\n",
    "                #At tround, calculate Q with exlpore boost for each arm\n",
    "                explore_boost_const = self.rho*np.log(tround)/self.arm_visit_count[arm]\n",
    "                \n",
    "                temp_arm_with_Q[arm] = temp_arm_with_Q[arm] + np.sqrt(explore_boost_const)\n",
    "            \n",
    "       #Getting the highest value from Q, then find the corresponding key and append them\n",
    "        highest = max(temp_arm_with_Q.values())\n",
    "        highest_Qs = [key for key, value in temp_arm_with_Q.items() if value == highest]\n",
    "        if len(highest_Qs)>1:\n",
    "            action = np.random.choice(highest_Qs)#Tie Breaker\n",
    "        else:\n",
    "            action = highest_Qs[0]\n",
    "        return action\n",
    "        \n",
    "    def update(self, arm, reward, context=None):\n",
    "        assert (arm > 0 and arm <=self.narms),\"arm must be positive integers and no larger than self.narms\"\n",
    "        assert (type(reward)==float or type(reward) == np.float64),\"reward must be floating point\"\n",
    "        #same as e-greedy\n",
    "        self.arm_visit_count[arm] += 1\n",
    "        self.arm_total_reward[arm] += reward\n",
    "        updated_reward = self.arm_total_reward[arm]/self.arm_visit_count[arm]\n",
    "        \n",
    "        self.arm_with_avg_reward.update({arm:updated_reward})\n",
    "        \n",
    "        return self.arm_with_avg_reward\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. The Basic Thompson Bandit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BetaThompson(MAB):\n",
    "    \"\"\"\n",
    "    Beta-Bernoulli Thompson sampling multi-armed bandit\n",
    "\n",
    "    Arguments\n",
    "    =========\n",
    "    narms : int\n",
    "        number of arms\n",
    "\n",
    "    alpha0 : float, optional\n",
    "        positive real prior hyperparameter\n",
    "\n",
    "    beta0 : float, optional\n",
    "        positive real prior hyperparameter\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, narms, alpha0=1.0, beta0=1.0):\n",
    "        assert (narms > 0),\"narms must be positive integers\"\n",
    "        assert (type(alpha0)==float and alpha0 >0.0 and np.isreal(alpha0)),\"alpha0 must be real positive floating number\"\n",
    "        assert (type(beta0)==float and beta0 >0.0 and np.isreal(beta0)),\"beta0 must be real positive floating number\"\n",
    "        \n",
    "        self.narms = narms\n",
    "        self.alpha0 = alpha0\n",
    "        self.beta0 = beta0\n",
    "        self.theta = np.random.beta(self.alpha0, self.beta0) #Initial theta based on default alpha and beta\n",
    "        \n",
    "        \n",
    "        self.arm_with_theta = {}\n",
    "        self.arm_with_alpha0 = {}\n",
    "        self.arm_with_beta0 = {}\n",
    "        \n",
    "        for arm in range(1,self.narms+1):\n",
    "            self.arm_with_theta[arm]=self.theta #Initial all the arm with theta\n",
    "            self.arm_with_alpha0[arm]=self.alpha0 #Initial all the arm with default alpha0\n",
    "            self.arm_with_beta0[arm]=self.beta0 #Initial all the arm with default beta0\n",
    "            \n",
    "        \n",
    "        \n",
    "    \n",
    "    def play(self, tround, context=None):\n",
    "        assert (tround > 0),\"tround must be positive integers\"\n",
    "        for arm in range(1,self.narms+1):\n",
    "            #For each arm, calculate theta\n",
    "            self.arm_with_theta[arm] = np.random.beta(self.arm_with_alpha0[arm]+1, self.arm_with_beta0[arm]+1)\n",
    "        #Getting the highest value from theta, then find the corresponding key and append them\n",
    "        highest = max(self.arm_with_theta.values())\n",
    "        highest_Qs = [key for key, value in self.arm_with_theta.items() if value == highest]\n",
    "        if len(highest_Qs)>1:\n",
    "            action = np.random.choice(highest_Qs)#Tie Breaker\n",
    "        else:\n",
    "            action = highest_Qs[0]\n",
    "        return action\n",
    "        \n",
    "        \n",
    "        \n",
    "    def update(self, arm, reward, context=None):\n",
    "        assert (arm > 0 and arm <=self.narms),\"arm must be positive integers and no larger than self.narms\"\n",
    "        assert (type(reward)==float or type(reward) == np.float64),\"reward must be floating point\"\n",
    "        #update alpha if there is a reward, in other case update beta.\n",
    "        if reward ==1:\n",
    "            self.arm_with_alpha0[arm] += 1\n",
    "        else:\n",
    "            self.arm_with_beta0[arm] += 1\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Off-Policy Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initial three lists which respects\n",
    "# to arm, reward, and context(feature_list in this case).\n",
    "arm_list = []\n",
    "reward_list = []\n",
    "features_list = []\n",
    "num_of_events = 0\n",
    "\n",
    "#Read each line and split by spaces. Record arm, reward and context into the lists\n",
    "with open(\"dataset.txt\",\"r\") as f:\n",
    "    dataset = f.readlines()\n",
    "for line in dataset:\n",
    "    num_of_events += 1\n",
    "    temp_line = line.split()\n",
    "    arm = int(temp_line[0])\n",
    "    reward = float(temp_line[1])\n",
    "    features = temp_line[2:]\n",
    "    features = list(map(float, features))\n",
    "    arm_list.append(arm)\n",
    "    reward_list.append(reward)\n",
    "    features_list.append(features)\n",
    "    \n",
    "#Convert lists into np_array\n",
    "arms = np.array(arm_list)\n",
    "rewards = np.array(reward_list)\n",
    "\n",
    "#For each event, the context is 10*10 dim \n",
    "# because there are 10 arms, and each one of them has 10 features \n",
    "contexts = np.array(features_list).reshape(num_of_events,(10*10))\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "def offlineEvaluate(mab, arms, rewards, contexts, nrounds=None):\n",
    "    \"\"\"\n",
    "    Offline evaluation of a multi-armed bandit\n",
    "    \n",
    "    Arguments\n",
    "    =========\n",
    "    mab : instance of MAB\n",
    "    \n",
    "    arms : 1D int array, shape (nevents,) \n",
    "        integer arm id for each event\n",
    "    \n",
    "    rewards : 1D float array, shape (nevents,)\n",
    "        reward received for each event\n",
    "    \n",
    "    contexts : 2D float array, shape (nevents, mab.narms*nfeatures)\n",
    "        contexts presented to the arms (stacked horizontally) \n",
    "        for each event.\n",
    "        \n",
    "    nrounds : int, optional\n",
    "        number of matching events to evaluate `mab` on.\n",
    "    \n",
    "    Returns\n",
    "    =======\n",
    "    out : 1D float array\n",
    "        rewards for the matching events\n",
    "    \"\"\"\n",
    "    assert(arms.shape==(num_of_events,)),\"1d array and in range[1...map.narms]\"\n",
    "    assert(rewards.shape==(num_of_events,)),\"must be 1d array\"\n",
    "    assert(nrounds >0 or nrounds is None),\"must be positive integer with default None\"\n",
    "    h0 = [] #History list \n",
    "    R0 = [] #Total Payoff\n",
    "        \n",
    "    count = 0\n",
    "    for event in range(num_of_events):\n",
    "        #If reach required number of rounds then stop\n",
    "        #If number of rounds not specified, then read untill last of events. \n",
    "        if len(h0) == nrounds: \n",
    "            \n",
    "            break\n",
    "        #Play an arm, but the tround is the number of history observed\n",
    "        action = mab.play(len(h0)+1,contexts[event])\n",
    "        \n",
    "        #If the chosen arm is equal to the arm in the log, \n",
    "        # then record history and payoff, and also update the arm.\n",
    "        if action == arms[event]:\n",
    "            count +=1\n",
    "            h0.append(event)\n",
    "            R0.append(rewards[event])\n",
    "            mab.update(arms[event],rewards[event],contexts[event])\n",
    "        \n",
    "    \n",
    "    return R0\n",
    "            \n",
    "\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "800\n",
      "EpsGreedy average reward 0.24875\n"
     ]
    }
   ],
   "source": [
    "mab = EpsGreedy(10, 0.05)\n",
    "results_EpsGreedy = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print(len(results_EpsGreedy))\n",
    "print('EpsGreedy average reward', np.mean(results_EpsGreedy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UCB average reward 0.0925\n"
     ]
    }
   ],
   "source": [
    "mab = UCB(10, 1.0)\n",
    "results_UCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('UCB average reward', np.mean(results_UCB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BetaThompson average reward 0.225\n"
     ]
    }
   ],
   "source": [
    "mab = BetaThompson(10, 1.0, 1.0)\n",
    "results_BetaThompson = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('BetaThompson average reward', np.mean(results_BetaThompson))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Contextual Bandits - LinUCB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinUCB(MAB):\n",
    "    \"\"\"\n",
    "    Contextual multi-armed bandit (LinUCB)\n",
    "\n",
    "    Arguments\n",
    "    =========\n",
    "    narms : int\n",
    "        number of arms\n",
    "\n",
    "    ndims : int\n",
    "        number of dimensions for each arm's context\n",
    "\n",
    "    alpha : float\n",
    "        positive real explore-exploit parameter\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, narms, ndims, alpha):\n",
    "        assert (narms > 0),\"narms must be positive integers\"\n",
    "        assert (ndims > 0),\"ndims must be positive integers\"\n",
    "        assert ((type(alpha)==float or type(alpha) == np.float64) and alpha >0.0 and np.isreal(alpha)),\"alpha must be real positive floating number\"\n",
    "        self.narms = narms\n",
    "        self.ndims = ndims\n",
    "        self.alpha = alpha\n",
    "\n",
    "        \n",
    "        self.A_a = {} #A is the list of each arm with D.T * D + I \n",
    "        self.b_a = {} #b is the reward list\n",
    "        \n",
    "        \n",
    "        for arm in range(1,self.narms+1):\n",
    "            if arm not in self.A_a:#If arm is new\n",
    "                #For each arm, initial identity matrix with feature dimensitonal space \n",
    "                self.A_a[arm] = np.identity(self.ndims)  \n",
    "            if arm not in self.b_a:\n",
    "                #For each arm, initial reward matrix with zeros. Dimension is each corresponding context's dimension\n",
    "                self.b_a[arm] = np.zeros(self.ndims)\n",
    "            \n",
    "         \n",
    "            \n",
    "        \n",
    "        \n",
    "    def play(self, tround, context):\n",
    "        assert (tround > 0),\"tround must be positive integers\"\n",
    "        \n",
    "        assert (context.shape == (self.narms*self.ndims,)),\"context must be a numeric array of length self.ndims * self.narms\"\n",
    "        arm_with_Q = {} #At tround, initial arm with empty posterior distribution\n",
    "        \n",
    "        context = context.reshape(self.narms,self.ndims)\n",
    "        \n",
    "        for arm in range(1,self.narms+1):\n",
    "            #For each arm, calculate posterior distribution based on theta and std\n",
    "            Theta_a = np.dot(np.linalg.inv(self.A_a[arm]),self.b_a[arm])\n",
    "            std = np.sqrt(np.linalg.multi_dot([np.transpose(context[arm-1]),np.linalg.inv(self.A_a[arm]),context[arm-1]]))\n",
    "            p_ta = np.dot(Theta_a.T,context[arm-1]) + self.alpha*std\n",
    "            \n",
    "            if not np.isnan(p_ta):#make sure the result of calculation is valid number\n",
    "                arm_with_Q[arm] = p_ta\n",
    "            \n",
    "        #Getting the highest value from posterior distribution, then find the corresponding key and append them\n",
    "        highest = max(arm_with_Q.values())\n",
    "        \n",
    "        highest_Qs = [key for key, value in arm_with_Q.items() if value == highest]\n",
    "        if len(highest_Qs)>1:\n",
    "            action = np.random.choice(highest_Qs)#Tie Breaker\n",
    "        else:\n",
    "            action = highest_Qs[0]\n",
    "        \n",
    "        return action\n",
    "        \n",
    "            \n",
    "            \n",
    "        \n",
    "        \n",
    "        \n",
    "    \n",
    "    def update(self, arm, reward, context):\n",
    "        assert (arm > 0 and arm <=self.narms),\"arm must be positive integers and no larger than self.narms\"\n",
    "        assert (type(reward)==float or type(reward) == np.float64),\"reward must be floating point\"\n",
    "        \n",
    "        assert (context.shape == (self.narms*self.ndims,)),\"context must be a numeric array of length self.ndims * self.narms\"\n",
    "        \n",
    "        context = context.reshape(self.narms,self.ndims)\n",
    "        \n",
    "        \n",
    "        if arm <= self.narms:\n",
    "            #Reshap the vector to matrix, or the calculation will be incorrect \n",
    "            #because the transpose will not take effects\n",
    "            context_Matrix = context[arm-1].reshape(-1,1)\n",
    "            context_times_contextT = np.dot(context_Matrix,context_Matrix.T)\n",
    "            \n",
    "            self.A_a[arm] = np.add(self.A_a[arm],context_times_contextT)\n",
    "            \n",
    "            self.b_a[arm] = np.add(self.b_a[arm],np.dot(reward,context[arm-1]))\n",
    "            \n",
    "            \n",
    "        \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinUCB average reward 0.53\n"
     ]
    }
   ],
   "source": [
    "mab = LinUCB(10, 10, 1.0)\n",
    "results_LinUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('LinUCB average reward', np.mean(results_LinUCB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Contextual Bandits - LinThompson"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinThompson(MAB):\n",
    "    \"\"\"\n",
    "    Contextual Thompson sampled multi-armed bandit (LinThompson)\n",
    "\n",
    "    Arguments\n",
    "    =========\n",
    "    narms : int\n",
    "        number of arms\n",
    "\n",
    "    ndims : int\n",
    "        number of dimensions for each arm's context\n",
    "\n",
    "    v : float\n",
    "        positive real explore-exploit parameter\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, narms, ndims, v):\n",
    "        assert (narms > 0),\"narms must be positive integers\"\n",
    "        assert (ndims > 0),\"ndims must be positive integers\"\n",
    "        assert ((type(v)==float or type(alpha) == np.float64) and v >0.0 and np.isreal(v)),\"v must be real positive floating number\"\n",
    "        self.narms = narms\n",
    "        self.ndims = ndims\n",
    "        self.v = v \n",
    "        \n",
    "        \n",
    "        self.B = np.identity(self.ndims) #Initial B with identity matrix which has ndims dimension\n",
    "        \n",
    "        \n",
    "        self.f = np.zeros(self.ndims) #Initial total payoff with ndims of zeros\n",
    "        \n",
    "        \n",
    "        self.u = np.zeros(self.ndims) #Initial parameter mu with ndims of zeros\n",
    "        \n",
    "       \n",
    "            \n",
    "                \n",
    "        \n",
    "        \n",
    "    def play(self, tround, context):\n",
    "        assert (tround > 0),\"tround must be positive integers\"\n",
    "        assert (context.shape == (self.narms*self.ndims,)),\"context must be a numeric array of length self.ndims * self.narms\"\n",
    "        \n",
    "        arm_with_Q = {}\n",
    "        \n",
    "        context = context.reshape(self.narms,self.ndims)\n",
    "        #Calculate prior from multivariate Gaussian distribution\n",
    "        u_t = np.random.multivariate_normal(self.u, self.v*self.v*np.linalg.inv(self.B))\n",
    "        \n",
    "        for arm in range(1,self.narms+1):\n",
    "            #calculate posterior distribution for each arm\n",
    "            arm_with_Q[arm] = np.dot(np.transpose(context[arm-1]),u_t)\n",
    "            \n",
    "        #Getting the highest value from posterior distribution, then find the corresponding key and append them\n",
    "        highest = max(arm_with_Q.values())\n",
    "        highest_Qs = [key for key, value in arm_with_Q.items() if value == highest]\n",
    "        if len(highest_Qs)>1:\n",
    "            action = np.random.choice(highest_Qs)#Tie Breaker\n",
    "        else:\n",
    "            action = highest_Qs[0]\n",
    "        return action\n",
    "            \n",
    "        \n",
    "    \n",
    "    def update(self, arm, reward, context):\n",
    "        assert (arm > 0 and arm <=self.narms),\"arm must be positive integers and no larger than self.narms\"\n",
    "        assert (type(reward)==float or type(reward) == np.float64),\"reward must be floating point\"\n",
    "        assert (context.shape == (self.narms*self.ndims,)),\"context must be a numeric array of length self.ndims * self.narms\"\n",
    "        \n",
    "        context = context.reshape(self.narms,self.ndims)\n",
    "\n",
    "        if arm <= self.narms:\n",
    "            #Reshap the vector to matrix, or the calculation will be incorrect \n",
    "            #because the transpose will not take effects\n",
    "            context_Matrix = context[arm-1].reshape(-1,1)\n",
    "            context_times_contextT = np.dot(context_Matrix,context_Matrix.T)\n",
    "            #Update B\n",
    "            self.B = np.add(self.B,context_times_contextT)\n",
    "            #Update reward f\n",
    "            self.f = np.add(self.f,np.multiply(reward,context[arm-1]))\n",
    "            #Update mu\n",
    "            self.u = np.dot(np.linalg.inv(self.B),self.f)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinThompson average reward 0.32\n"
     ]
    }
   ],
   "source": [
    "mab = LinThompson(10, 10, 1.0)\n",
    "results_LinThompson = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "print('LinThompson average reward', np.mean(results_LinThompson))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Evaluation\n",
    "### 6.A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "EpsGreedy_reward = []\n",
    "UCB_reward = []\n",
    "betaThompson_reward = []\n",
    "linUCB_reward = []\n",
    "linThompson_reward = []\n",
    "total_round = []\n",
    "count = 0\n",
    "for round in range(1,801):\n",
    "    count +=1\n",
    "    total_round.append(count)\n",
    "    if round ==1: #calculate initial reward \n",
    "        EpsGreedy_reward.append(results_EpsGreedy[round-1]/round)\n",
    "        UCB_reward.append(results_UCB[round-1]/round)\n",
    "        betaThompson_reward.append(results_BetaThompson[round-1]/round)\n",
    "        linUCB_reward.append(results_LinUCB[round-1]/round)\n",
    "        linThompson_reward.append(results_LinThompson[round-1]/round)\n",
    "    else: #calculate cumulated reward\n",
    "        results_EpsGreedy[round-1] += results_EpsGreedy[round-2] \n",
    "        EpsGreedy_reward.append(results_EpsGreedy[round-1]/round)\n",
    "        \n",
    "        results_UCB[round-1]+= results_UCB[round-2]\n",
    "        UCB_reward.append(results_UCB[round-1]/round)\n",
    "        \n",
    "        results_BetaThompson[round-1]+= results_BetaThompson[round-2]\n",
    "        betaThompson_reward.append(results_BetaThompson[round-1]/round)\n",
    "        \n",
    "        results_LinUCB[round-1]+= results_LinUCB[round-2]\n",
    "        linUCB_reward.append(results_LinUCB[round-1]/round)\n",
    "        \n",
    "        results_LinThompson[round-1] += results_LinThompson[round-2]\n",
    "        linThompson_reward.append(results_LinThompson[round-1]/round)\n",
    "        \n",
    "plt.plot(total_round,EpsGreedy_reward, label = \"eGreedy\")\n",
    "plt.plot(total_round,UCB_reward, label = \"UCB\")\n",
    "plt.plot(total_round,betaThompson_reward, label = \"BetaThompson\")\n",
    "plt.plot(total_round,linUCB_reward, label = \"LinUCB\")\n",
    "plt.plot(total_round,linThompson_reward, label = \"LinThompson\")\n",
    "plt.ylabel('Per-Round Cumulative Reward')\n",
    "plt.xlabel('Rounds')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "#First Interval [0.2 0.4 0.6 0.8 1. ]\n",
    "alpha_range_one_decimal = np.linspace(0,1,6) \n",
    "alpha_range_one_decimal = np.delete(alpha_range_one_decimal,0)#delete zero\n",
    "#Second Interval [0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 ]\n",
    "alpha_range_two_decimal = np.linspace(0,0.1,11)\n",
    "alpha_range_two_decimal = np.delete(alpha_range_two_decimal,0)#delete zero\n",
    "#Append two intervals and sort\n",
    "alpha_range = np.append(alpha_range_two_decimal,alpha_range_one_decimal) \n",
    "alpha_range = np.sort(alpha_range)\n",
    "results_LinUCB_with_alpha = []\n",
    "\n",
    "for alpha in alpha_range:\n",
    "    mab = LinUCB(10, 10, alpha)\n",
    "    results_LinUCB = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "    results_LinUCB_with_alpha.append(np.mean(results_LinUCB))\n",
    "   \n",
    "    \n",
    "plt.plot(alpha_range, results_LinUCB_with_alpha,linestyle='dashed')\n",
    "plt.ylabel('mean_reward')\n",
    "plt.xlabel('apha_range')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "#First Interval [0.2 0.4 0.6 0.8 1. ]\n",
    "v_range_one_decimal = np.linspace(0,1,6)\n",
    "v_range_one_decimal = np.delete(v_range_one_decimal,0)#delete zero\n",
    "#Second Interval [0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 ]\n",
    "v_range_two_decimal = np.linspace(0,0.1,11)\n",
    "v_range_two_decimal = np.delete(v_range_two_decimal,0)#delete zero\n",
    "#Append two intervals and sort\n",
    "v_range = np.append(v_range_two_decimal,v_range_one_decimal) \n",
    "v_range = np.sort(v_range)\n",
    "\n",
    "resutls_LinThompson_with_v = []\n",
    "for v in v_range:\n",
    "    mab = LinThompson(10, 10,v)\n",
    "    results_LinThompson = offlineEvaluate(mab, arms, rewards, contexts, 800)\n",
    "    resutls_LinThompson_with_v.append(np.mean(results_LinThompson))\n",
    "plt.plot(v_range, resutls_LinThompson_with_v,linestyle='dashed')\n",
    "plt.ylabel('mean_reward')\n",
    "plt.xlabel('v_range')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}