Dueling_DQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ac8c412f",
   "metadata": {},
   "source": [
    "# Dueling_DQN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5b6f9be1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing necessary packages\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "from typing import Dict, List, Tuple\n",
    "from IPython.display import clear_output\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e0efb92c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#getting the device \n",
    "#cuda if gpu else cpu\n",
    "device=torch.device(\"cuda\" if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95622c90",
   "metadata": {},
   "source": [
    "### Cartpole environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cfc984ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "env=gym.make(\"CartPole-v0\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2d90d56",
   "metadata": {},
   "source": [
    "### Dueling Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "05cae8e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating the neural network\n",
    "class Network(nn.Module):\n",
    "    def __init__(self,in_dimension,out_dimension):\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        # set common feature layer\n",
    "        self.feature_layer = nn.Sequential(\n",
    "            nn.Linear(in_dimension, 128), \n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        # set advantage layer\n",
    "        self.advantage_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, out_dimension),\n",
    "        )\n",
    "\n",
    "        # set value layer\n",
    "        self.value_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 1),\n",
    "        )\n",
    "        \n",
    "    def forward(self,x:torch.Tensor)->torch.Tensor:\n",
    "        #forward propagation\n",
    "        feature = self.feature_layer(x)\n",
    "        value = self.value_layer(feature)\n",
    "        advantage = self.advantage_layer(feature)\n",
    "        q = value + advantage - advantage.mean(dim=-1, keepdim=True)\n",
    "        return q\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7cd0099",
   "metadata": {},
   "source": [
    "### Replay buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bd90f675",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self,obs_dim,size,batch_size:int=32):\n",
    "        \n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "    def store(self,obs,act,rew,next_obs,done):\n",
    "        #storing all necesary info\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        #sampling the replay buffer\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],next_obs=self.next_obs_buf[idxs],acts=self.acts_buf[idxs],rews=self.rews_buf[idxs],done=self.done_buf[idxs])\n",
    "    def __len__(self):\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "66437fb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN:\n",
    "    def __init__(self,env,memory_size,batch_size,target_update,epsilon_decay,max_epsilon=1.00,min_epsilon=0.1,gamma=0.99):\n",
    "        #state size and action size\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        #environment,epsilon and discount factor\n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        #network\n",
    "        self.dqn = Network(obs_dim, action_dim).to(device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        #optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "        #transition to store in memory\n",
    "        self.transition = list()\n",
    "        # mode: train or test\n",
    "        self.is_test = False\n",
    "        \n",
    "    def select_action(self,state)->np.ndarray:\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(device)).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        return selected_action\n",
    "    def step(self,action)->Tuple[np.ndarray, np.float64, bool]:\n",
    "        #Take an action and return the response of the environment\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "        return next_state, reward, done\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        #Update the model by gradient descent\n",
    "        samples = self.memory.sample_batch()\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        return loss.item()\n",
    "    def train(self,num_frames,plotting_interval=200):\n",
    "        #train the agent\n",
    "        self.is_test = False\n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        for frame_idx in range(1,num_frames+1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "            state = next_state\n",
    "            score += reward\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(self.min_epsilon,self.epsilon-(self.max_epsilon - self.min_epsilon) * self.epsilon_decay)\n",
    "                epsilons.append(self.epsilon)\n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "                # plotting\n",
    "                if frame_idx % plotting_interval == 0:\n",
    "                    self._plot(frame_idx, scores, losses, epsilons)\n",
    "        self.env.close()\n",
    "    def test(self) -> List[np.ndarray]:\n",
    "        #testing the agent\n",
    "        self.is_test = True\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        return frames\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        #Return dqn loss.\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r   otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(\n",
    "            next_state\n",
    "        ).max(dim=1, keepdim=True)[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(device)\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "        return loss\n",
    "    def _target_hard_update(self):\n",
    "        #Hard update: target <- local\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "    def _plot(self,frame_idx,scores,losses,epsilons):\n",
    "        #Plot the training progresses\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "de500fba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "609e30d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "agent = DQN(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3a949ad9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "aad5d237",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8117756b",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}