Switching for Cloud vs Local server.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f6923447",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import statistics as stat "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6f3e97e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rewardnstate(a, s):\n",
    "    r, state, terminal = P[s][a]\n",
    "    if s==1 and a==0:\n",
    "        r = r + np.random.uniform(-1, 1)\n",
    "    return r, state, terminal\n",
    "\n",
    "def act_functn(Q, state, state_visits, nAfes):\n",
    "    #eps = 0.2\n",
    "    #eps = 1/np.power(state_visits[state], 0.2)\n",
    "    eps = 1/np.sqrt(state_visits[state])\n",
    "    if np.random.choice([True, False], p=[1-eps, eps]):\n",
    "        action = np.argmax(Q[state, :nAfes[state]])\n",
    "    else:\n",
    "        action = np.random.choice(nAfes[state])\n",
    "    return action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a5f0c2d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(epochs, gamma, rewardnstate, act_functn, P, seed=1, alpha=0.05):\n",
    "    def double_Qlearning(Qa, Qb,\n",
    "                         cumsum, count,\n",
    "                         count_matrix_a, maximal_value_a, \n",
    "                         maximal_value,\n",
    "                         rewardnstate, action,\n",
    "                         state, reward_list,\n",
    "                         state_visits):\n",
    "        reward, next_state, terminal = rewardnstate(action, state)\n",
    "        cumsum += reward\n",
    "        count += 1\n",
    "        alpha_a = 1/np.power(count_matrix_a[state, action], p)\n",
    "        action_star = np.argmax(Qa[next_state, :nAfes[next_state]])\n",
    "        Qa[state, action] += alpha_a*(reward + gamma*Qb[next_state, action_star] - Qa[state, action])\n",
    "        count_matrix_a[state, action] += 1\n",
    "        state_visits[state] += 1\n",
    "        maximal_value_a.append(np.max(Qa[start_state, :nAfes[start_state]]))\n",
    "        maximal_value.append(np.max(Qa[start_state, :nAfes[start_state]]))\n",
    "        reward_list.append((state, action, reward))\n",
    "        return (reward_list, maximal_value_a,\n",
    "                maximal_value, state_visits,\n",
    "                count_matrix_a, Qa,\n",
    "                next_state, terminal,\n",
    "                cumsum, count)    \n",
    "    \n",
    "    def Qlearning(Qa, cumsum,\n",
    "                  count, count_matrix_a,\n",
    "                  maximal_value_a, maximal_value, \n",
    "                  rewardnstate,\n",
    "                  action, state, reward_list,\n",
    "                  state_visits):\n",
    "        reward, next_state, terminal = rewardnstate(action, state)\n",
    "        cumsum += reward\n",
    "        count += 1\n",
    "        alpha_a = 1/np.power(count_matrix_a[state, action], p)\n",
    "        Qa[state, action] += alpha_a*(reward + gamma*np.max(Qa[next_state, :nAfes[next_state]]) - Qa[state, action])\n",
    "        count_matrix_a[state, action] += 1\n",
    "        state_visits[state] += 1\n",
    "        maximal_value_a.append(np.max(Qa[start_state, :nAfes[start_state]]))\n",
    "        maximal_value.append(np.max(Qa[start_state, :nAfes[start_state]]))\n",
    "        reward_list.append((state, action, reward))\n",
    "        return (reward_list, maximal_value_a,\n",
    "                maximal_value, state_visits,\n",
    "                count_matrix_a, Qa,\n",
    "                next_state, terminal,\n",
    "                cumsum, count)\n",
    "    \n",
    "    np.random.seed(seed)\n",
    "    nS = 2\n",
    "    nA = 2\n",
    "    state_visits = np.ones(nS)\n",
    "    maximal_value = []\n",
    "    pref_list = []\n",
    "    pref_learning_list = [] #0: double q learning, 1: q learning \n",
    "    cumsum = 0\n",
    "    count = 0\n",
    "\n",
    "    Q = np.random.rand(2, nS, nA)\n",
    "    Q[0, 0] = 0\n",
    "    Q[1, 0] = 0\n",
    "    count_matrix = np.ones([2, nS, nA])\n",
    "    maximal_value_v = [[], []]\n",
    "    nAfes = [1, 2] #num_Actions_for_each_state\n",
    "    start_state = 1\n",
    "    avg_reward_per_step = []\n",
    "    return_dict = {\n",
    "            0: {0: []},\n",
    "            1: {\n",
    "                0: [], 1: []\n",
    "            }\n",
    "        }\n",
    "    for i in range(epochs):\n",
    "        reward_list = []\n",
    "        state = start_state#state = np.random.choice(nS)\n",
    "        terminal = True if state==0 else False\n",
    "        choice = np.random.choice([True, False]).astype(\"int\")\n",
    "        \n",
    "        while not terminal:\n",
    "            action = act_functn(Q[choice], state, state_visits, nAfes)\n",
    "            opt_action = np.argmax(np.mean(Q[:, state], axis=0))\n",
    "            other_action = 1-opt_action #0 if 1; 1 if 0\n",
    "\n",
    "            # Double Q learning is preferred if \n",
    "            #  we have more than 2 previous returns for a state action pair\n",
    "            #  and the variance of return is less a threshold\n",
    "            # In case either of the above two criteria are not followed\n",
    "            # Q learning is preferred. \n",
    "            \n",
    "            if(len(return_dict[state][action]) >= 2):\n",
    "                if(np.var(return_dict[state][opt_action])<np.var(return_dict[state][other_action])):\n",
    "                    \n",
    "                    \n",
    "                    choice2 = np.random.choice([True, False]).astype(\"int\")                    \n",
    "                    (reward_list, maximal_value_v[choice2],\n",
    "                      maximal_value, state_visits,\n",
    "                      count_matrix[choice2], Qc2, next_state,\n",
    "                      terminal, cumsum, \n",
    "                     count) = double_Qlearning(Q[choice2], Q[1-choice2],\n",
    "                                              cumsum, count,\n",
    "                                              count_matrix[choice2], \n",
    "                                              maximal_value_v[choice2],\n",
    "                                               maximal_value,\n",
    "                                              rewardnstate, action,\n",
    "                                              state, reward_list,\n",
    "                                              state_visits)\n",
    "                    Q[choice2] = Qc2\n",
    "                    pref_learning_list.append(0) #Double qlearning\n",
    "                else:\n",
    "                    \n",
    "                    (reward_list, maximal_value_v[choice],\n",
    "                    maximal_value, state_visits,\n",
    "                    count_matrix[choice], Q[choice], next_state,\n",
    "                    terminal, cumsum, count) = Qlearning(Q[choice], cumsum,\n",
    "                                                          count, count_matrix[choice],\n",
    "                                                          maximal_value_v[choice], \n",
    "                                                          maximal_value,\n",
    "                                                          rewardnstate, action, \n",
    "                                                          state, reward_list,\n",
    "                                                          state_visits)\n",
    "                    pref_learning_list.append(1) #qlearning\n",
    "            else:\n",
    "                \n",
    "                (reward_list, maximal_value_v[choice],\n",
    "                 maximal_value, state_visits,\n",
    "                 count_matrix[choice], Q[choice], next_state,\n",
    "                 terminal, cumsum, count) = Qlearning(Q[choice], cumsum,\n",
    "                                                      count, count_matrix[choice],\n",
    "                                                      maximal_value_v[choice], \n",
    "                                                      maximal_value,\n",
    "                                                      rewardnstate, action, \n",
    "                                                      state, reward_list,\n",
    "                                                      state_visits)\n",
    "                pref_learning_list.append(1) #qlearning\n",
    "            state = next_state\n",
    "            reward_sum = 0\n",
    "            for i in range(len(reward_list)-1, -1, -1):\n",
    "                reward_sum = gamma*reward_sum + reward_list[i][2]\n",
    "                return_dict[reward_list[i][0]][reward_list[i][1]].append(reward_sum)\n",
    "\n",
    "        pref = .0\n",
    "        pref += Q[0][1][0] - Q[0][1][1] #preference of left over right\n",
    "        pref += Q[1][1][0] - Q[1][1][1] #preference of left over right\n",
    "        pref /= float(2)\n",
    "        pref_list.append(pref)\n",
    "        avg_reward_per_step.append(cumsum/count)\n",
    "    return (avg_reward_per_step, pref_list, pref_learning_list, \n",
    "            Q[0], Q[1], maximal_value_v[0], maximal_value_v[1], \n",
    "            maximal_value, return_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9fb17262",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0370942404188357\n"
     ]
    }
   ],
   "source": [
    "N = 3\n",
    "alpha = 0.01\n",
    "gamma = 0.99\n",
    "epochs = 2000\n",
    "p = 0.8\n",
    "for i in [1]:\n",
    "    mu = i\n",
    "    P = {\n",
    "        0:{0: (0, 0, True)}, #state:{action: (reward, next state, terminal)}\n",
    "        1:{0: (mu, 0, True),\n",
    "           1: (0, 0, True)}\n",
    "    }\n",
    "    (reward_list, pref_list,\n",
    "     pref_learning_list, Qa,\n",
    "     Qb, maximal_value_a,\n",
    "     maximal_value_b, maximal_value,\n",
    "     return_dict) = train(epochs, gamma, rewardnstate, act_functn, P)\n",
    "    print(pref_list[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d92b50cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2000, 2000, 0, 0)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pref_learning_array = np.array(pref_learning_list)\n",
    "maximal_value_array = np.array(maximal_value)\n",
    "qchosen = (pref_learning_array).nonzero()[0]\n",
    "qchosen_maximal_value = maximal_value_array[qchosen]\n",
    "dqchosen =(1-pref_learning_array).nonzero()[0]\n",
    "dqchosen_maximal_value = maximal_value_array[dqchosen]\n",
    "len(qchosen), len(qchosen_maximal_value), len(dqchosen), len(dqchosen_maximal_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1b89caa0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1550x650 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "red_dot, = ax.plot(dqchosen, dqchosen_maximal_value, \"r.\", markersize=5)\n",
    "blue_dot, = ax.plot(qchosen,qchosen_maximal_value, \"b.\",  markersize=5)\n",
    "\n",
    "ax.legend([red_dot, (red_dot, blue_dot)], [\"dq chosen\", \"q chosen\"])\n",
    "fig.set_size_inches(15.5, 6.5, forward=True)\n",
    "plt.title(\"mu={}\".format(mu))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "aec37511",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(np.array([0, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6689251",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}