Simulated_Linear_MDP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from itertools import product\n",
    "from scipy.optimize import minimize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinearMDP_train():\n",
    "    def __init__(self, action_space, delta, xi_norm, seed=1):\n",
    "        np.random.seed(seed)\n",
    "        self.state_space = ['x1', 'x2', 'x3', 'x4', 'x5']\n",
    "        self.action_space = action_space\n",
    "        self.initial_state = 'x1'\n",
    "        self.theta = [np.zeros(4), \n",
    "                      np.array([0,0,0,1]), \n",
    "                      np.array([0,0,0,1])]\n",
    "        self.delta = delta\n",
    "        Xi = np.full(len(self.action_space[0]), 1)\n",
    "        self.Xi = xi_norm * Xi / np.linalg.norm(Xi, 1)\n",
    "\n",
    "    def reset(self):\n",
    "        self.S = [self.initial_state]\n",
    "        self.A = [] # save the action history\n",
    "        self.R = [] # save the reward history\n",
    "        self.h = 0 # reset the step to 0\n",
    "        self.feature = [] # save the feature trajectory\n",
    "        self.feature_a = [] # save the full feature trajectory\n",
    "        self.current_state = self.initial_state  # reset the current state to initial state\n",
    "    \n",
    "    def phi(self, current_state, A):\n",
    "        if current_state == 'x1':\n",
    "            phi = np.array([1 - self.delta - self.Xi @ A, 0, 0, self.delta + self.Xi @ A])\n",
    "        elif current_state == 'x2':\n",
    "            phi = np.array([0, 1 - self.delta - self.Xi @ A, 0, self.delta + self.Xi @ A])\n",
    "        elif current_state == 'x3':\n",
    "            phi = np.array([0, 0, 1- self.delta - self.Xi @ A, self.delta + self.Xi @ A])\n",
    "        elif current_state == 'x4':\n",
    "            phi = np.array([0,0,1,0])\n",
    "        else:\n",
    "            phi = np.array([0,0,0,1])\n",
    "        return phi\n",
    "\n",
    "    def add_state(self, s): \n",
    "        self.S.append(s)\n",
    "        self.current_state = s\n",
    "\n",
    "    def update_state(self, phi, h):\n",
    "        # claculate the transition probability\n",
    "        if h == 0:\n",
    "            prob = [phi[0] * (1-0.001), 0, phi[0]* 0.001, phi[3]]\n",
    "        elif h == 1:\n",
    "            if phi[2] == 1:\n",
    "                prob = [0, 0, 1, 0]\n",
    "            elif phi[3] == 1:\n",
    "                prob = [0, 0, 0, 1]\n",
    "            else:\n",
    "                prob = [0, phi[1] * (1 - 0.001), phi[1]* 0.001, phi[3]]\n",
    "        else:\n",
    "            prob = [0, 0, phi[2], phi[3]]\n",
    "        sprime = np.random.choice(range(1,5), size=1, p=prob)[0]\n",
    "        return self.state_space[sprime] # return a string\n",
    "\n",
    "    def next_state(self, phi):\n",
    "        next_state = self.update_state(phi, self.h)\n",
    "        self.add_state(next_state)\n",
    "        return next_state\n",
    "\n",
    "    def generate_reward(self, phi):\n",
    "        reward = np.dot(phi, self.theta[self.h])\n",
    "        self.R.append(reward)\n",
    "        return reward\n",
    "\n",
    "    def step(self, a):\n",
    "        self.A.append(a)\n",
    "        phi = self.phi(self.current_state, a)\n",
    "        phi_a = [self.phi(self.current_state, a) for a in self.action_space]\n",
    "        self.feature.append(phi)\n",
    "        self.feature_a.append(phi_a)\n",
    "        self.generate_reward(phi)\n",
    "        self.next_state(phi)\n",
    "        self.h += 1\n",
    "    \n",
    "class LinearMDP_test():\n",
    "    \"\"\"Pertubed environment\"\"\"\n",
    "    def __init__(self, nominal_MDP, q, seed=1):\n",
    "        np.random.seed(seed)\n",
    "        self.state_space = nominal_MDP.state_space\n",
    "        self.action_space = nominal_MDP.action_space\n",
    "        self.initial_state = 'x1'\n",
    "        self.theta = nominal_MDP.theta\n",
    "        self.delta = nominal_MDP.delta\n",
    "        self.Xi = nominal_MDP.Xi\n",
    "        self.q = q\n",
    "\n",
    "    def reset(self):\n",
    "        self.S = [self.initial_state] # save the feature trajectory\n",
    "        self.A = [] # save the action history\n",
    "        self.R = [] # save the reward history\n",
    "        self.h = 0 # reset the step to 0\n",
    "        self.feature = [] # save the feature trajectory\n",
    "        self.feature_a = [] # save the full feature trajectory\n",
    "        self.current_state = self.initial_state  # reset the current state to initial state\n",
    "\n",
    "    def phi(self, current_state, A):\n",
    "        if current_state == 'x1':\n",
    "            phi = np.array([1 - self.delta - self.Xi @ A, 0, 0, self.delta + self.Xi @ A])\n",
    "        elif current_state == 'x2':\n",
    "            phi = np.array([0, 1 - self.delta - self.Xi @ A, 0, self.delta + self.Xi @ A])\n",
    "        elif current_state == 'x3':\n",
    "            phi = np.array([0, 0, 1- self.delta - self.Xi @ A, self.delta + self.Xi @ A])\n",
    "        elif current_state == 'x4':\n",
    "            phi = np.array([0,0,1,0])\n",
    "        else:\n",
    "            phi = np.array([0,0,0,1])\n",
    "        return phi\n",
    "\n",
    "    def add_state(self, s): \n",
    "        self.S.append(s)\n",
    "        self.current_state = s\n",
    "\n",
    "    def update_state(self, phi, h):\n",
    "        # claculate the transition probability --- perturbed\n",
    "        if h == 0:\n",
    "            prob = [phi[0], 0, self.q * phi[3], (1 - self.q) * phi[3]]\n",
    "        elif h == 1:\n",
    "            if phi[2] == 1:\n",
    "                prob = [0, 0, 1, 0]\n",
    "            elif phi[3] == 1:\n",
    "                prob = [0, 0, 0, 1]\n",
    "            else:\n",
    "                prob = [0, phi[1] * (1 - 0.001), phi[1]* 0.001, phi[3]]\n",
    "        else:\n",
    "            prob = [0, 0, phi[2], phi[3]]\n",
    "        sprime = np.random.choice(range(1,5), size=1, p=prob)[0]\n",
    "        return self.state_space[sprime] # return a string\n",
    "\n",
    "    def next_state(self, phi):\n",
    "        next_state = self.update_state(phi, self.h)\n",
    "        self.add_state(next_state)\n",
    "        return next_state\n",
    "\n",
    "    def generate_reward(self, phi):\n",
    "        reward = np.dot(phi, self.theta[self.h])\n",
    "        self.R.append(reward)\n",
    "        return reward\n",
    "    \n",
    "    def step(self, a):\n",
    "        self.A.append(a)\n",
    "        phi = self.phi(self.current_state, a)\n",
    "        phi_a = [self.phi(self.current_state, a) for a in self.action_space]\n",
    "        self.feature.append(phi)\n",
    "        self.feature_a.append(phi_a)\n",
    "        self.generate_reward(phi)\n",
    "        self.next_state(phi)\n",
    "        self.h += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSVI_UCB():\n",
    "    def __init__(self, A, beta, H, lam, fail_state=None):\n",
    "        self.lam = lam\n",
    "        self.H = H\n",
    "        self.action_space = A\n",
    "        self.beta = beta\n",
    "        self.w = [np.zeros(4) for _ in range(self.H)]\n",
    "        self.Lambda = [self.lam * np.diag(np.ones(4)) for _ in range(self.H)]\n",
    "        self.fail_state = fail_state\n",
    "\n",
    "    def get_action(self, phi_a,  h):\n",
    "        Q_h = [self.get_Q_func(phi_a[idx], h) for idx in range(len(self.action_space))]\n",
    "        return self.action_space[np.argmax(Q_h)]\n",
    "    \n",
    "    def get_Q_func(self, phi, h, s_f=False):\n",
    "        if s_f == True:\n",
    "            return 0\n",
    "        else:\n",
    "            Lambda_h_inverse = np.linalg.inv(self.Lambda[h])\n",
    "            Q_h = np.min([(self.w[h] @ phi + self.beta * np.sqrt(phi @ Lambda_h_inverse @ phi)), self.H])\n",
    "            return Q_h \n",
    "\n",
    "    def update_Q(self, history): \n",
    "        # Backward induction\n",
    "        self.w = [None for _ in range(self.H)] # initialize weights w\n",
    "        for h in range(self.H-1, -1, -1):\n",
    "            # update Lambda_h\n",
    "            phi_h = history['phi'][-1][h]\n",
    "            self.Lambda[h] += np.outer(phi_h, phi_h)\n",
    "            # update w_h \n",
    "            Lambda_h_inverse = np.linalg.inv(self.Lambda[h])\n",
    "            w_h = np.zeros(4)\n",
    "            if h == self.H - 1:\n",
    "                for tau in range(history['k']):\n",
    "                    phi_tau_h = history['phi'][tau][h]\n",
    "                    r_tau_h = history['r'][tau][h]\n",
    "                    w_h += Lambda_h_inverse @ (phi_tau_h * r_tau_h)\n",
    "            else:\n",
    "                for tau in range(history['k']):\n",
    "                    phi_tau_h = history['phi'][tau][h]\n",
    "                    phi_tau_h_plus_one = history['phi_a'][tau][h+1]\n",
    "                    r_tau_h = history['r'][tau][h]\n",
    "                    s_f_h_plus_one = (history['state'][tau][h+1] == self.fail_state)\n",
    "                    Q_tau_h_plus_one = [self.get_Q_func(phi_tau_h_plus_one[idx], h + 1, s_f_h_plus_one)\n",
    "                                        for idx in range(len(self.action_space))]\n",
    "                    V_tau_h_plus_one = np.max(Q_tau_h_plus_one)\n",
    "                    w_h += Lambda_h_inverse @ (phi_tau_h * (r_tau_h + V_tau_h_plus_one))   \n",
    "            self.w[h] = w_h         \n",
    "\n",
    "class DR_LSVI_UCB():\n",
    "    def __init__(self, A, beta, H, lam, Rho, theta, fail_state=None):\n",
    "        self.lam = lam\n",
    "        self.H = H\n",
    "        self.action_space = A\n",
    "        self.beta = beta\n",
    "        self.w = [np.zeros(4) for _ in range(self.H)]\n",
    "        self.Lambda = [self.lam * np.diag(np.ones(4)) for _ in range(self.H)]\n",
    "        self.Rho = Rho\n",
    "        self.theta = theta\n",
    "        self.fail_state = fail_state\n",
    "\n",
    "    def get_action(self, phi_a,  h):\n",
    "        Q_h = [self.get_Q_func(phi_a[idx], h) for idx in range(len(self.action_space))]\n",
    "        return self.action_space[np.argmax(Q_h)]\n",
    "    \n",
    "    def get_Q_func(self, phi, h, s_f=False):\n",
    "        if s_f == True:\n",
    "            return 0\n",
    "        else:\n",
    "            Lambda_h_inverse = np.linalg.inv(self.Lambda[h])\n",
    "            bonus =  self.beta * np.sqrt(phi @ np.diag(np.diagonal(Lambda_h_inverse)) @ phi)\n",
    "            Q_h = np.min([(self.w[h] @ phi + bonus), self.H - h])\n",
    "            return Q_h \n",
    "        \n",
    "    def get_nu_h(self, history, h, rho):\n",
    "        Lambda_h_inverse = np.linalg.inv(self.Lambda[h])\n",
    "        nu_h = np.zeros(4)  \n",
    "        Phi_h = np.zeros((0,4)) \n",
    "        V_h_plus_one = np.zeros(0)\n",
    "        for tau in range(history['k']): \n",
    "            phi_tau_h = history['phi'][tau][h]\n",
    "            Phi_h = np.vstack((Phi_h, phi_tau_h))\n",
    "            phi_tau_h_plus_one = history['phi_a'][tau][h+1]\n",
    "            s_f_h_plus_one = (history['state'][tau][h+1] == self.fail_state)\n",
    "            Q_tau_h_plus_one = [self.get_Q_func(phi_tau_h_plus_one[idx], h + 1, s_f_h_plus_one) \n",
    "                                for idx in range(len(self.action_space))]\n",
    "            V_tau_h_plus_one = np.max(Q_tau_h_plus_one)\n",
    "            V_h_plus_one = np.hstack((V_h_plus_one, V_tau_h_plus_one))\n",
    "        for i in range(4):\n",
    "            def z_alpha_i(alpha):\n",
    "                # compact formular for z\n",
    "                z = Lambda_h_inverse @ Phi_h.T @ np.minimum(V_h_plus_one, alpha)\n",
    "                return -z[i] + rho[i]*alpha\n",
    "            result =  minimize(z_alpha_i, self.H/2, method='Nelder-Mead', bounds=[(0,self.H)])\n",
    "            nu_h[i] = - result.fun\n",
    "            #print(result.x)\n",
    "        return nu_h\n",
    "    \n",
    "    def update_Q(self, history): \n",
    "        # Backward induction\n",
    "        self.w = [None for _ in range(self.H)] # initialize weights w\n",
    "        for h in range(self.H-1, -1, -1):\n",
    "            # update Lambda_h\n",
    "            phi_h = history['phi'][-1][h]\n",
    "            self.Lambda[h] += np.outer(phi_h, phi_h)\n",
    "            # update w_h \n",
    "            w_h = np.zeros(4)\n",
    "            nu_h = np.zeros(4)\n",
    "            if h == self.H - 1:\n",
    "                w_h = self.theta[h]\n",
    "            else:\n",
    "                nu_h = self.get_nu_h(history, h, rho=self.Rho[h])\n",
    "                w_h = self.theta[h] + nu_h\n",
    "            self.w[h] = w_h  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_once(epoch, action_space, beta, delta, xi_norm, H, lam, fail_state, seed):\n",
    "    history = {'k': 0, 'phi':[], 'r':[], 'state':[], 'phi_a':[]}\n",
    "    env = LinearMDP_train(action_space, delta, xi_norm, seed=seed)\n",
    "    agent = LSVI_UCB(A=action_space, beta=beta, H=H, lam=lam, fail_state=fail_state)\n",
    "    reward = 0\n",
    "    Reward = []\n",
    "    for t in range(epoch):\n",
    "        env.reset()\n",
    "        for h in range(H):\n",
    "            current_state = env.current_state\n",
    "            phi_a = [env.phi(current_state, a) for a in action_space]\n",
    "            action = agent.get_action(phi_a, h)\n",
    "            env.step(action)\n",
    "        # log the trajectory\n",
    "        history['phi_a'].append(env.feature_a)\n",
    "        history['phi'].append(env.feature)\n",
    "        history['r'].append(env.R)\n",
    "        history['state'].append(env.S)\n",
    "        history['k'] += 1\n",
    "        # update the agent\n",
    "        agent.update_Q(history)\n",
    "        reward += np.sum(env.R)\n",
    "        Reward.append(reward)\n",
    "    return agent\n",
    "\n",
    "def train_once_DR(epoch, action_space, beta, delta, xi_norm, Rho, H, lam, fail_state, seed):\n",
    "    history = {'k': 0, 'phi':[], 'r':[], 'state':[], 'phi_a':[]}\n",
    "    env = LinearMDP_train(action_space, delta, xi_norm, seed=seed)\n",
    "    DR_agent = DR_LSVI_UCB(A=action_space, beta=beta, H=H, lam=lam, Rho=Rho, theta=env.theta, fail_state=fail_state)\n",
    "    reward = 0\n",
    "    Reward = []\n",
    "    for t in range(epoch):\n",
    "        env.reset()\n",
    "        for h in range(H):\n",
    "            current_state = env.current_state\n",
    "            phi_a = [env.phi(current_state, a) for a in action_space]\n",
    "            action = DR_agent.get_action(phi_a, h)\n",
    "            env.step(action)\n",
    "        # log the trajectory\n",
    "        history['phi_a'].append(env.feature_a)\n",
    "        history['phi'].append(env.feature)\n",
    "        history['r'].append(env.R)\n",
    "        history['state'].append(env.S)\n",
    "        history['k'] += 1\n",
    "        # update the agent\n",
    "        DR_agent.update_Q(history)\n",
    "        reward += np.sum(env.R)\n",
    "        Reward.append(reward)\n",
    "    return DR_agent\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "T1 = 100\n",
    "H = 3\n",
    "rho = 0.3\n",
    "beta = 1\n",
    "lam = 0.1\n",
    "actions = list(product([-1, 1], repeat=4))\n",
    "action_space = [np.array(action) for action in actions]\n",
    "delta = 0.3\n",
    "xi_norm = 0.1\n",
    "Rho = [[0,0,0,rho], [0,0,0,0]]\n",
    "fail_state = 'x4'\n",
    "replication = 20\n",
    "agent_dic = {}\n",
    "DR_agent_dic = {}\n",
    "\n",
    "for rep in range(replication):\n",
    "    agent = train_once(epoch=T1, action_space=action_space, beta=beta, delta=delta, \n",
    "                       xi_norm=xi_norm, H=H, lam=lam, fail_state=fail_state, seed=rep)\n",
    "    DR_agent = train_once_DR(epoch=T1, action_space=action_space, beta=beta, delta=delta, \n",
    "                             xi_norm=xi_norm, Rho=Rho, H=H, lam=lam, fail_state=fail_state, seed=rep)\n",
    "    agent_dic[str(rep)] = agent\n",
    "    DR_agent_dic[str(rep)] = DR_agent\n",
    "    \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Perturbation = [x / 20 for x in range(21)]\n",
    "T2 = 100\n",
    "R_LSVI_UCB = []\n",
    "R_DR_LSVI_UCB = []\n",
    "env = LinearMDP_train(action_space, delta, xi_norm)\n",
    "for q in Perturbation:\n",
    "    REWARD = 0\n",
    "    REWARD_DR = 0\n",
    "    for rep in range(replication):\n",
    "        reward = 0\n",
    "        reward_DR = 0\n",
    "        env_test = LinearMDP_test(env, q=q, seed=rep)\n",
    "        env_test_DR = LinearMDP_test(env, q=q, seed=rep)\n",
    "        agent = agent_dic[str(rep)]\n",
    "        DR_agent = DR_agent_dic[str(rep)]\n",
    "        \n",
    "        for t in range(T2):\n",
    "            env_test.reset()\n",
    "            env_test_DR.reset()\n",
    "            for h in range(H):\n",
    "                current_state = env_test.current_state\n",
    "                phi = [env_test.phi(current_state, a) for a in action_space]\n",
    "                action = agent.get_action(phi, h)\n",
    "\n",
    "                current_state_DR = env_test_DR.current_state\n",
    "                phi_DR = [env_test_DR.phi(current_state_DR, a) for a in action_space]\n",
    "                action_DR = DR_agent.get_action(phi_DR, h)\n",
    "                \n",
    "                env_test.step(action)\n",
    "                env_test_DR.step(action_DR)\n",
    "            reward += np.sum(env_test.R)/T2\n",
    "            reward_DR += np.sum(env_test_DR.R)/T2\n",
    "        REWARD += reward / replication\n",
    "        REWARD_DR += reward_DR / replication\n",
    "\n",
    "    R_LSVI_UCB.append(REWARD)\n",
    "    R_DR_LSVI_UCB.append(REWARD_DR)\n",
    "plt.plot(Perturbation, R_LSVI_UCB, label = 'LSVI-UCB')\n",
    "plt.plot(Perturbation, R_DR_LSVI_UCB, label = 'DR-LSVI-UCB')\n",
    "plt.legend(fontsize=16)\n",
    "plt.xlabel('Perturbation', size=16)\n",
    "plt.ylabel('Average reward', size=16)\n",
    "plt.savefig(f'robustness_{delta}_{xi_norm}_{rho}.pdf', dpi=1000, bbox_inches='tight', pad_inches=0.0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}