05.DQN-NoisyNets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q Network with Noisy Networks for Exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from IPython.display import clear_output\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from timeit import default_timer as timer\n",
    "from datetime import timedelta\n",
    "import math\n",
    "\n",
    "from utils.wrappers import *\n",
    "from agents.DQN import Model as DQN_Agent\n",
    "from utils.ReplayMemory import ExperienceReplayMemory\n",
    "\n",
    "from utils.hyperparameters import Config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = Config()\n",
    "\n",
    "config.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "config.NOISY_NETS=True\n",
    "\n",
    "#epsilon variables\n",
    "config.SIGMA_INIT=0.5\n",
    "\n",
    "#misc agent variables\n",
    "config.GAMMA=0.99\n",
    "config.LR=1e-4\n",
    "\n",
    "#memory\n",
    "config.TARGET_NET_UPDATE_FREQ = 1000\n",
    "config.EXP_REPLAY_SIZE = 100000\n",
    "config.BATCH_SIZE = 32\n",
    "\n",
    "#Learning control variables\n",
    "config.LEARN_START = 10000\n",
    "config.MAX_FRAMES=700000\n",
    "\n",
    "#Nstep controls\n",
    "config.N_STEPS=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NoisyLinear(nn.Module):\n",
    "    def __init__(self, in_features, out_features, std_init=0.4):\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        self.in_features = in_features\n",
    "        self.out_features = out_features\n",
    "        self.std_init = std_init\n",
    "        self.weight_mu = nn.Parameter(torch.empty(out_features, in_features))\n",
    "        self.weight_sigma = nn.Parameter(torch.empty(out_features, in_features))\n",
    "        self.register_buffer('weight_epsilon', torch.empty(out_features, in_features))\n",
    "        self.bias_mu = nn.Parameter(torch.empty(out_features))\n",
    "        self.bias_sigma = nn.Parameter(torch.empty(out_features))\n",
    "        self.register_buffer('bias_epsilon', torch.empty(out_features))\n",
    "        self.reset_parameters()\n",
    "        self.sample_noise()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        mu_range = 1.0 / math.sqrt(self.in_features)\n",
    "        self.weight_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.in_features))\n",
    "        self.bias_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.out_features))\n",
    "\n",
    "    def _scale_noise(self, size):\n",
    "        x = torch.randn(size)\n",
    "        return x.sign().mul_(x.abs().sqrt_())\n",
    "\n",
    "    def sample_noise(self):\n",
    "        epsilon_in = self._scale_noise(self.in_features)\n",
    "        epsilon_out = self._scale_noise(self.out_features)\n",
    "        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n",
    "        self.bias_epsilon.copy_(epsilon_out)\n",
    "\n",
    "    def forward(self, inp):\n",
    "        if self.training:\n",
    "            return F.linear(inp, self.weight_mu + self.weight_sigma * self.weight_epsilon, self.bias_mu + self.bias_sigma * self.bias_epsilon)\n",
    "        else:\n",
    "            return F.linear(inp, self.weight_mu, self.bias_mu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN(nn.Module):\n",
    "    def __init__(self, input_shape, num_actions, sigma_init=0.5):\n",
    "        super(DQN, self).__init__()\n",
    "        \n",
    "        self.input_shape = input_shape\n",
    "        self.num_actions = num_actions\n",
    "\n",
    "        self.conv1 = nn.Conv2d(self.input_shape[0], 32, kernel_size=8, stride=4)\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)\n",
    "        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, stride=1)\n",
    "\n",
    "        self.fc1 = NoisyLinear(self.feature_size(), 512, sigma_init)\n",
    "        self.fc2 = NoisyLinear(512, self.num_actions, sigma_init)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "\n",
    "        return x\n",
    "    \n",
    "    def feature_size(self):\n",
    "        return self.conv3(self.conv2(self.conv1(torch.zeros(1, *self.input_shape)))).view(1, -1).size(1)\n",
    "\n",
    "    def sample_noise(self):\n",
    "        self.fc1.sample_noise()\n",
    "        self.fc2.sample_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(DQN_Agent):\n",
    "    def __init__(self, static_policy=False, env=None, config=None):\n",
    "        super(Model, self).__init__(static_policy, env, config)\n",
    "    \n",
    "    def declare_networks(self):\n",
    "        self.model = DQN(self.num_feats, self.num_actions)\n",
    "        self.target_model = DQN(self.num_feats, self.num_actions)\n",
    "        \n",
    "    def compute_loss(self, batch_vars):\n",
    "        batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values, indices, weights = batch_vars\n",
    "\n",
    "        #estimate\n",
    "        self.model.sample_noise()\n",
    "        current_q_values = self.model(batch_state).gather(1, batch_action)\n",
    "        \n",
    "        #target\n",
    "        with torch.no_grad():\n",
    "            max_next_q_values = torch.zeros(self.batch_size, device=self.device, dtype=torch.float).unsqueeze(dim=1)\n",
    "            if not empty_next_state_values:\n",
    "                max_next_action = self.get_max_next_state_action(non_final_next_states)\n",
    "                self.target_model.sample_noise()\n",
    "                max_next_q_values[non_final_mask] = self.target_model(non_final_next_states).gather(1, max_next_action)\n",
    "            expected_q_values = batch_reward + ((self.gamma**self.nsteps)*max_next_q_values)\n",
    "\n",
    "        diff = (expected_q_values - current_q_values)\n",
    "        loss = self.huber(diff)\n",
    "        loss = loss.mean()\n",
    "\n",
    "        return loss\n",
    "        \n",
    "    def get_action(self, s, eps=0.1):\n",
    "        with torch.no_grad():\n",
    "            X = torch.tensor([s], device=self.device, dtype=torch.float)\n",
    "            self.model.sample_noise()\n",
    "            a = self.model(X).max(1)[1].view(1, 1)\n",
    "            return a.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot(frame_idx, rewards, losses, sigma, elapsed_time):\n",
    "    clear_output(True)\n",
    "    plt.figure(figsize=(20,5))\n",
    "    plt.subplot(131)\n",
    "    plt.title('frame %s. reward: %s. time: %s' % (frame_idx, np.mean(rewards[-10:]), elapsed_time))\n",
    "    plt.plot(rewards)\n",
    "    if losses:\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "    if sigma:\n",
    "        plt.subplot(133)\n",
    "        plt.title('noisy param magnitude')\n",
    "        plt.plot(sigma)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "start=timer()\n",
    "\n",
    "env_id = \"PongNoFrameskip-v4\"\n",
    "env    = make_atari(env_id)\n",
    "env    = wrap_deepmind(env, frame_stack=False)\n",
    "env    = wrap_pytorch(env)\n",
    "model = Model(env=env, config=config)\n",
    "\n",
    "episode_reward = 0\n",
    "\n",
    "observation = env.reset()\n",
    "for frame_idx in range(1, config.MAX_FRAMES + 1):\n",
    "    action = model.get_action(observation)\n",
    "    prev_observation=observation\n",
    "    observation, reward, done, _ = env.step(action)\n",
    "    observation = None if done else observation\n",
    "\n",
    "    model.update(prev_observation, action, reward, observation, frame_idx)\n",
    "    episode_reward += reward\n",
    "\n",
    "    if done:\n",
    "        model.finish_nstep()\n",
    "        model.reset_hx()\n",
    "        observation = env.reset()\n",
    "        model.save_reward(episode_reward)\n",
    "        episode_reward = 0\n",
    "        \n",
    "        if np.mean(model.rewards[-10:]) > 19:\n",
    "            plot(frame_idx, all_rewards, losses, timedelta(seconds=int(timer()-start)))\n",
    "            break\n",
    "\n",
    "    if frame_idx % 10000 == 0:\n",
    "        plot(frame_idx, model.rewards, model.losses, model.sigma_parameter_mag, timedelta(seconds=int(timer()-start)))\n",
    "\n",
    "model.save_w()\n",
    "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}