01.DQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "from gym import wrappers\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from IPython.display import clear_output\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import random\n",
    "from timeit import default_timer as timer\n",
    "from datetime import timedelta\n",
    "import math\n",
    "from utils.wrappers import make_atari, wrap_deepmind, wrap_pytorch\n",
    "\n",
    "from utils.hyperparameters import Config\n",
    "from agents.BaseAgent import BaseAgent"
   ]
  },
  {
   "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",
    "#epsilon variables\n",
    "config.epsilon_start = 1.0\n",
    "config.epsilon_final = 0.01\n",
    "config.epsilon_decay = 30000\n",
    "config.epsilon_by_frame = lambda frame_idx: config.epsilon_final + (config.epsilon_start - config.epsilon_final) * math.exp(-1. * frame_idx / config.epsilon_decay)\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=1000000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay Memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExperienceReplayMemory:\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity\n",
    "        self.memory = []\n",
    "\n",
    "    def push(self, transition):\n",
    "        self.memory.append(transition)\n",
    "        if len(self.memory) > self.capacity:\n",
    "            del self.memory[0]\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        return random.sample(self.memory, batch_size)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network Declaration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN(nn.Module):\n",
    "    def __init__(self, input_shape, num_actions):\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 = nn.Linear(self.feature_size(), 512)\n",
    "        self.fc2 = nn.Linear(512, self.num_actions)\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(BaseAgent):\n",
    "    def __init__(self, static_policy=False, env=None, config=None):\n",
    "        super(Model, self).__init__()\n",
    "        self.device = config.device\n",
    "\n",
    "        self.gamma = config.GAMMA\n",
    "        self.lr = config.LR\n",
    "        self.target_net_update_freq = config.TARGET_NET_UPDATE_FREQ\n",
    "        self.experience_replay_size = config.EXP_REPLAY_SIZE\n",
    "        self.batch_size = config.BATCH_SIZE\n",
    "        self.learn_start = config.LEARN_START\n",
    "\n",
    "        self.static_policy = static_policy\n",
    "        self.num_feats = env.observation_space.shape\n",
    "        self.num_actions = env.action_space.n\n",
    "        self.env = env\n",
    "\n",
    "        self.declare_networks()\n",
    "            \n",
    "        self.target_model.load_state_dict(self.model.state_dict())\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr)\n",
    "        \n",
    "        #move to correct device\n",
    "        self.model = self.model.to(self.device)\n",
    "        self.target_model.to(self.device)\n",
    "\n",
    "        if self.static_policy:\n",
    "            self.model.eval()\n",
    "            self.target_model.eval()\n",
    "        else:\n",
    "            self.model.train()\n",
    "            self.target_model.train()\n",
    "\n",
    "        self.update_count = 0\n",
    "\n",
    "        self.declare_memory()\n",
    "        \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 declare_memory(self):\n",
    "        self.memory = ExperienceReplayMemory(self.experience_replay_size)\n",
    "\n",
    "    def append_to_replay(self, s, a, r, s_):\n",
    "        self.memory.push((s, a, r, s_))\n",
    "\n",
    "\n",
    "    def prep_minibatch(self):\n",
    "        # random transition batch is taken from experience replay memory\n",
    "        transitions = self.memory.sample(self.batch_size)\n",
    "        \n",
    "        batch_state, batch_action, batch_reward, batch_next_state = zip(*transitions)\n",
    "\n",
    "        shape = (-1,)+self.num_feats\n",
    "\n",
    "        batch_state = torch.tensor(batch_state, device=self.device, dtype=torch.float).view(shape)\n",
    "        batch_action = torch.tensor(batch_action, device=self.device, dtype=torch.long).squeeze().view(-1, 1)\n",
    "        batch_reward = torch.tensor(batch_reward, device=self.device, dtype=torch.float).squeeze().view(-1, 1)\n",
    "        \n",
    "        non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, batch_next_state)), device=self.device, dtype=torch.uint8)\n",
    "        try: #sometimes all next states are false\n",
    "            non_final_next_states = torch.tensor([s for s in batch_next_state if s is not None], device=self.sdevice, dtype=torch.float).view(shape)\n",
    "            empty_next_state_values = False\n",
    "        except:\n",
    "            non_final_next_states = None\n",
    "            empty_next_state_values = True\n",
    "\n",
    "        return batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values\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 = batch_vars\n",
    "\n",
    "        #estimate\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",
    "                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*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 update(self, s, a, r, s_, frame=0):\n",
    "        if self.static_policy:\n",
    "            return None\n",
    "\n",
    "        self.append_to_replay(s, a, r, s_)\n",
    "\n",
    "        if frame < self.learn_start:\n",
    "            return None\n",
    "\n",
    "        batch_vars = self.prep_minibatch()\n",
    "\n",
    "        loss = self.compute_loss(batch_vars)\n",
    "\n",
    "        # Optimize the model\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        for param in self.model.parameters():\n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step()\n",
    "\n",
    "        self.update_target_model()\n",
    "        self.save_loss(loss.item())\n",
    "        self.save_sigma_param_magnitudes()\n",
    "\n",
    "\n",
    "    def get_action(self, s, eps=0.1):\n",
    "        with torch.no_grad():\n",
    "            if np.random.random() >= eps or self.static_policy:\n",
    "                X = torch.tensor([s], device=self.device, dtype=torch.float)\n",
    "                a = self.model(X).max(1)[1].view(1, 1)\n",
    "                return a.item()\n",
    "            else:\n",
    "                return np.random.randint(0, self.num_actions)\n",
    "\n",
    "    def update_target_model(self):\n",
    "        self.update_count+=1\n",
    "        self.update_count = self.update_count % self.target_net_update_freq\n",
    "        if self.update_count == 0:\n",
    "            self.target_model.load_state_dict(self.model.state_dict())\n",
    "\n",
    "    def get_max_next_state_action(self, next_states):\n",
    "        return self.target_model(next_states).max(dim=1)[1].view(-1, 1)\n",
    "\n",
    "    def huber(self, x):\n",
    "        cond = (x.abs() < 1.0).to(torch.float)\n",
    "        return 0.5 * x.pow(2) * cond + (x.abs() - 0.5) * (1 - cond)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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",
    "    epsilon = config.epsilon_by_frame(frame_idx)\n",
    "\n",
    "    action = model.get_action(observation, epsilon)\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",
    "        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, model.rewards, model.losses, model.sigma_parameter_mag, 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": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}