DQN/LunarLander/LunarLander_DQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network (DQN)\n",
    "---\n",
    "In this notebook, we'll implement a DQN agent with OpenAI Gym's LunarLander-v2 environment.\n",
    "\n",
    "### 1. Import the Necessary Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from collections import deque, namedtuple\n",
    "import numpy as np\n",
    "import random\n",
    "import copy\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "device = torch.device('cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Instantiate the Environment and Agent\n",
    "\n",
    "Initialize the environment in the code cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sans/.local/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
      "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('LunarLander-v2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action_size = env.action_space.n\n",
    "action_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], dtype=float32),\n",
       " array([inf, inf, inf, inf, inf, inf, inf, inf], dtype=float32),\n",
       " 8)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state_low = env.observation_space.low\n",
    "state_high = env.observation_space.high\n",
    "state_size = len(state_low)\n",
    "state_low, state_high, state_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Define hyperparameters\n",
    "\n",
    "These are **really** important, because small change in the parameter values can really \n",
    "affect the training time and efficency. \n",
    "My training was really affected by learning rate and number of nodes in the hidden layer. \n",
    "I first set up my LR = 0.01, - it trained fine at first but used to decline after the avg. \n",
    "rewards reach 150. So, I set up my LR = 0.0005 and it trained faster and efficently.\n",
    "\n",
    "Also, do not complicate the network. Increasing number of hidden layers and nodes surely\n",
    "might increase your training efficeny, but also take care of the time it will take to train.\n",
    "So, start with a simpler model with small number of hidden layer with small number of \n",
    "hidden nodes - it might just work for your need"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = int(1e5)\n",
    "BATCH_SIZE = 64\n",
    "GAMMA = 1.0\n",
    "UPDATE_EVERY = 4\n",
    "TAU = 1e-3\n",
    "LR = 5e-4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Define Model\n",
    "\n",
    "Initialize the model - take care that I have not added an activation function in the output\n",
    "layer of the network, because we will use that to calculate our Q values in the end for \n",
    "our loss function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(nn.Module):\n",
    "    def __init__(self, state_size, action_size):\n",
    "        super(Model, self).__init__()\n",
    "        self.seed = torch.manual_seed(42)\n",
    "        \n",
    "        self.fc1 = nn.Linear(state_size, 64)\n",
    "        self.fc2 = nn.Linear(64, 64)\n",
    "        self.fc3 = nn.Linear(64, action_size)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        \n",
    "        state = F.relu(self.fc1(state))\n",
    "        state = F.relu(self.fc2(state))\n",
    "        \n",
    "        action_values = self.fc3(state)\n",
    "        \n",
    "        return action_values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Instantiate ReplayBuffer\n",
    "\n",
    "A reply memory to sample the previous experiences taken out in random to learn and train \n",
    "our neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, buffer_size, action_size):\n",
    "        self.seed = random.seed(42)\n",
    "        self.action_size = action_size\n",
    "        self.memory = deque(maxlen=buffer_size)\n",
    "        self.experiences = namedtuple(\"Experiences\", field_names=[\"state\",\"action\",\"reward\",\"new_state\", \"done\"])\n",
    "        \n",
    "    def add(self, state, action, reward, new_state, done):\n",
    "        e = self.experiences(state, action, reward, new_state, done)\n",
    "        self.memory.append(e)\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        experiences = random.sample(self.memory, k=batch_size)\n",
    "        \n",
    "        states = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)\n",
    "        actions = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)\n",
    "        rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)\n",
    "        new_states = torch.from_numpy(np.vstack([e.new_state for e in experiences if e is not None])).float().to(device)\n",
    "        dones = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(device)\n",
    "        \n",
    "        return states, actions, rewards, new_states, dones\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Initialize the Agent\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    def __init__(self, state_size, action_size):\n",
    "        \n",
    "        self.seed = random.seed(42)\n",
    "        self.action_size = action_size\n",
    "        \n",
    "        self.local_nn = Model(state_size, action_size).to(device)\n",
    "        self.target_nn = Model(state_size, action_size).to(device)\n",
    "        \n",
    "        self.optimizer = optim.Adam(self.local_nn.parameters(), lr=LR)\n",
    "        \n",
    "        self.memory = ReplayBuffer(BUFFER_SIZE, action_size)\n",
    "        \n",
    "        self.t_step = 0\n",
    "        \n",
    "        \n",
    "    def step(self, state, action, reward, new_state, done):\n",
    "        self.memory.add(state, action, reward, new_state, done)\n",
    "        \n",
    "        self.t_step = (self.t_step + 1) % UPDATE_EVERY\n",
    "        if self.t_step == 0:\n",
    "            if len(self.memory) > BATCH_SIZE:\n",
    "                experiences = self.memory.sample(BATCH_SIZE)\n",
    "                self.learn(experiences, GAMMA)\n",
    "                \n",
    "    def act(self, state, eps = 0.):\n",
    "        state = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
    "        self.local_nn.eval()\n",
    "        with torch.no_grad():\n",
    "            action_values = self.local_nn(state)\n",
    "        self.local_nn.train()\n",
    "        \n",
    "        if random.random() > eps:\n",
    "            return np.argmax(action_values.cpu().data.numpy())\n",
    "        else:\n",
    "            return random.choice(np.arange(self.action_size))\n",
    "        \n",
    "    def learn(self, experiences, gamma):\n",
    "        states, actions, rewards, new_states, dones = experiences\n",
    "        \n",
    "        Q_target = self.target_nn(new_states).detach().max(1)[0].unsqueeze(1)\n",
    "        Q_target_value = rewards + (gamma * Q_target * (1-dones))\n",
    "        \n",
    "        Q_exp = self.local_nn(states).gather(1, actions)\n",
    "        loss = F.mse_loss(Q_exp, Q_target_value)\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        self.soft_update(self.local_nn, self.target_nn, TAU)\n",
    "        \n",
    "    def soft_update(self, local_nn, target_nn, tau):\n",
    "        for local_nn_params, target_nn_params in zip(local_nn.parameters(), target_nn.parameters()):\n",
    "            target_nn_params.data.copy_(tau*local_nn_params.data + (1.0-tau)*target_nn_params.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_size, action_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Train the Agent with DQN\n",
    "\n",
    "Run the code cell below to train the agent from scratch.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dqn():\n",
    "    n_episodes = 5000\n",
    "    score_deque = deque(maxlen=100)\n",
    "    scores = []\n",
    "    eps = 1.0\n",
    "    decay = 0.995\n",
    "    min_eps = 0.005\n",
    "    \n",
    "    for i_episode in range(n_episodes):\n",
    "        state = env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        while not done:\n",
    "            action = agent.act(state, eps)\n",
    "            new_state, reward, done, _ = env.step(action)\n",
    "            agent.step(state, action, reward, new_state, done)\n",
    "            state = new_state\n",
    "            score += reward\n",
    "            if done:\n",
    "                break\n",
    "                \n",
    "        score_deque.append(score)\n",
    "        scores.append(score)\n",
    "        \n",
    "        eps = max(min_eps, eps*decay)\n",
    "        \n",
    "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(score_deque)), end=\"\")\n",
    "        if i_episode % 100 == 0:\n",
    "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(score_deque)))\n",
    "        if np.mean(score_deque)>=200.0:\n",
    "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(score_deque)))\n",
    "            torch.save(agent.local_nn.state_dict(), 'checkpoint.pth')\n",
    "            break\n",
    "    return scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 0\tAverage Score: -287.69\n",
      "Episode 100\tAverage Score: -162.30\n",
      "Episode 200\tAverage Score: -97.003\n",
      "Episode 300\tAverage Score: -59.63\n",
      "Episode 400\tAverage Score: -12.71\n",
      "Episode 500\tAverage Score: 124.86\n",
      "Episode 554\tAverage Score: 200.65\n",
      "Environment solved in 454 episodes!\tAverage Score: 200.65\n"
     ]
    }
   ],
   "source": [
    "scores = dqn()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "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": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(len(scores)), scores)\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Watch a Smart Agent\n",
    "\n",
    "Load the saved model weights from a pre-trained agent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250.92628030953185\n"
     ]
    }
   ],
   "source": [
    "state = env.reset()\n",
    "done = False\n",
    "score = 0 \n",
    "agent.local_nn.load_state_dict(torch.load('checkpoint.pth'))\n",
    "# agent.local_nn.eval(\n",
    "while not done:\n",
    "    env.render()\n",
    "    action = agent.act(state)\n",
    "    state, reward, done, _ = env.step(action)\n",
    "    score += reward\n",
    "    if done:\n",
    "        print(score)\n",
    "        break\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}