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": 5,
   "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": 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": {},
   "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",
    "    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, 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
}