demo10-q-learning.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VLtuvsr88j5g"
      },
      "source": [
        "# Deep Q-Networks\n",
        "\n",
        "In this notebook, we will explore policy learning in RL by appropriately training neural networks for predicting Q-functions. These will be called Deep Q-networks (or DQN).  This notebook is taken from this [excellent repo](https://github.com/Curt-Park/rainbow-is-all-you-need)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H2Hubctq8j5h",
        "outputId": "f44d4ea9-73b4-467e-a3f9-0712f1fa7047"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "The following additional packages will be installed:\n",
            "  freeglut3\n",
            "Suggested packages:\n",
            "  libgle3\n",
            "The following NEW packages will be installed:\n",
            "  freeglut3 python-opengl\n",
            "0 upgraded, 2 newly installed, 0 to remove and 5 not upgraded.\n",
            "Need to get 570 kB of archives.\n",
            "After this operation, 5,733 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic/universe amd64 freeglut3 amd64 2.8.1-3 [73.6 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu bionic/universe amd64 python-opengl all 3.1.0+dfsg-1 [496 kB]\n",
            "Fetched 570 kB in 1s (745 kB/s)\n",
            "Selecting previously unselected package freeglut3:amd64.\n",
            "(Reading database ... 123941 files and directories currently installed.)\n",
            "Preparing to unpack .../freeglut3_2.8.1-3_amd64.deb ...\n",
            "Unpacking freeglut3:amd64 (2.8.1-3) ...\n",
            "Selecting previously unselected package python-opengl.\n",
            "Preparing to unpack .../python-opengl_3.1.0+dfsg-1_all.deb ...\n",
            "Unpacking python-opengl (3.1.0+dfsg-1) ...\n",
            "Setting up freeglut3:amd64 (2.8.1-3) ...\n",
            "Setting up python-opengl (3.1.0+dfsg-1) ...\n",
            "Processing triggers for libc-bin (2.27-3ubuntu1.6) ...\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "ffmpeg is already the newest version (7:3.4.11-0ubuntu0.1).\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "0 upgraded, 0 newly installed, 0 to remove and 5 not upgraded.\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "The following NEW packages will be installed:\n",
            "  xvfb\n",
            "0 upgraded, 1 newly installed, 0 to remove and 5 not upgraded.\n",
            "Need to get 785 kB of archives.\n",
            "After this operation, 2,271 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic-updates/universe amd64 xvfb amd64 2:1.19.6-1ubuntu4.11 [785 kB]\n",
            "Fetched 785 kB in 1s (1,136 kB/s)\n",
            "Selecting previously unselected package xvfb.\n",
            "(Reading database ... 126301 files and directories currently installed.)\n",
            "Preparing to unpack .../xvfb_2%3a1.19.6-1ubuntu4.11_amd64.deb ...\n",
            "Unpacking xvfb (2:1.19.6-1ubuntu4.11) ...\n",
            "Setting up xvfb (2:1.19.6-1ubuntu4.11) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pyvirtualdisplay\n",
            "  Downloading PyVirtualDisplay-3.0-py3-none-any.whl (15 kB)\n",
            "Installing collected packages: pyvirtualdisplay\n",
            "Successfully installed pyvirtualdisplay-3.0\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: gym in /usr/local/lib/python3.7/dist-packages (0.25.2)\n",
            "Requirement already satisfied: numpy>=1.18.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.21.6)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.5.0)\n",
            "Requirement already satisfied: gym-notices>=0.0.4 in /usr/local/lib/python3.7/dist-packages (from gym) (0.0.8)\n",
            "Requirement already satisfied: importlib-metadata>=4.8.0 in /usr/local/lib/python3.7/dist-packages (from gym) (4.13.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.8.0->gym) (4.1.1)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.8.0->gym) (3.10.0)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: gym[box2d] in /usr/local/lib/python3.7/dist-packages (0.25.2)\n",
            "Requirement already satisfied: numpy>=1.18.0 in /usr/local/lib/python3.7/dist-packages (from gym[box2d]) (1.21.6)\n",
            "Requirement already satisfied: gym-notices>=0.0.4 in /usr/local/lib/python3.7/dist-packages (from gym[box2d]) (0.0.8)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym[box2d]) (1.5.0)\n",
            "Requirement already satisfied: importlib-metadata>=4.8.0 in /usr/local/lib/python3.7/dist-packages (from gym[box2d]) (4.13.0)\n",
            "Collecting swig==4.*\n",
            "  Downloading swig-4.1.0-py2.py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.whl (1.8 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.8 MB 11.0 MB/s \n",
            "\u001b[?25hCollecting box2d-py==2.3.5\n",
            "  Downloading box2d_py-2.3.5-cp37-cp37m-manylinux1_x86_64.whl (2.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 2.1 MB 49.5 MB/s \n",
            "\u001b[?25hCollecting pygame==2.1.0\n",
            "  Downloading pygame-2.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 18.3 MB 97 kB/s \n",
            "\u001b[?25hRequirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.8.0->gym[box2d]) (3.10.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.8.0->gym[box2d]) (4.1.1)\n",
            "Installing collected packages: swig, pygame, box2d-py\n",
            "Successfully installed box2d-py-2.3.5 pygame-2.1.0 swig-4.1.0\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following packages will be REMOVED:\n",
            "  libnvidia-common-460\n",
            "0 upgraded, 0 newly installed, 1 to remove and 5 not upgraded.\n",
            "After this operation, 35.8 kB disk space will be freed.\n",
            "(Reading database ... 126308 files and directories currently installed.)\n",
            "Removing libnvidia-common-460 (460.106.00-0ubuntu1) ...\n"
          ]
        }
      ],
      "source": [
        "import sys\n",
        "IN_COLAB = \"google.colab\" in sys.modules\n",
        "\n",
        "if IN_COLAB:\n",
        "    !apt install python-opengl\n",
        "    !apt install ffmpeg\n",
        "    !apt install xvfb\n",
        "    !pip install pyvirtualdisplay\n",
        "    !pip install gym\n",
        "    !pip install gym[box2d]\n",
        "    !apt autoremove"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_VEj3H6L8j5i"
      },
      "source": [
        "# DQN training\n",
        "\n",
        "At a very high level, Q-learning is simple to grasp. In [class](https://chinmayhegde.github.io/dl-notes/notes/lecture10/) we showed that Q-learning can be viewed as optimizing the Bellman error:\n",
        "$$\n",
        "L = \\frac{1}{2} \\mathbb{E} (r + \\gamma \\max_{a'} Q(s',a') - Q(s,a))^2\n",
        "$$\n",
        "where the expectation is taken over sample 4-tuples $(s,a,r,s')$, and the variables in the loss function are the parameters of a deep neural network that approximates $Q$. \n",
        "\n",
        "\n",
        "In practical Q-learning, there are 3 more points to keep in mind:\n",
        "\n",
        "* *Target updates vs prediction updates*. There are two places where $Q$ appears in the Bellman error above, but really we are keeping the $Q$ in the second part, i.e., the $r + \\gamma \\max Q(s',a')$ in the Bellman error *fixed*. In other words, the ``target'' value is fixed (and updated only occasionally) while the prediction is updated with every sample.\n",
        "\n",
        "* *Gradient clipping* -- The Bellman error defined above involves a squared-error loss, but in order to prevent gradient blow-ups, it is common to *clip* the gradient to $\\pm 1$. This is equivalent to replacing the squared error loss with the [smoothed L1 loss](https://pytorch.org/docs/stable/generated/torch.nn.SmoothL1Loss.html).\n",
        "\n",
        "* *Experience replay*. The 4-tuples $(s,a,r,s')$ are obtained by keeping track of trajectories/episodes that happen over time. This history is stored in a deque, or ND-array, called a *replay buffer*, which can be queried uniformly at random to extract samples.\n",
        "\n",
        "Let us see how this works. First we perform some standard imports.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "FwGedGkQ8j5n"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "from typing import Dict, List, Tuple\n",
        "\n",
        "import gym\n",
        "import matplotlib.pyplot as plt\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\n",
        "from IPython.display import clear_output"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZumzeQ788j5n"
      },
      "source": [
        "\n",
        "\n",
        "Let us now implement a replay buffer using `numpy.ndarray`.\n",
        "\n",
        "\n",
        "Reference: [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "CurGtu8g8j5o"
      },
      "outputs": [],
      "source": [
        "class ReplayBuffer:\n",
        "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
        "\n",
        "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\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",
        "\n",
        "    def store(\n",
        "        self,\n",
        "        obs: np.ndarray,\n",
        "        act: np.ndarray, \n",
        "        rew: float, \n",
        "        next_obs: np.ndarray, \n",
        "        done: bool,\n",
        "    ):\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",
        "\n",
        "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
        "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
        "        return dict(obs=self.obs_buf[idxs],\n",
        "                    next_obs=self.next_obs_buf[idxs],\n",
        "                    acts=self.acts_buf[idxs],\n",
        "                    rews=self.rews_buf[idxs],\n",
        "                    done=self.done_buf[idxs])\n",
        "\n",
        "    def __len__(self) -> int:\n",
        "        return self.size"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lx6t7P8y8j5o"
      },
      "source": [
        "Our DQN is going to be rather simple, with 2 hidden layers and ReLU activations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "xJvllA4o8j5o"
      },
      "outputs": [],
      "source": [
        "class Network(nn.Module):\n",
        "    def __init__(self, in_dim: int, out_dim: int):\n",
        "        \"\"\"Initialization.\"\"\"\n",
        "        super(Network, self).__init__()\n",
        "\n",
        "        self.layers = nn.Sequential(\n",
        "            nn.Linear(in_dim, 128), \n",
        "            nn.ReLU(),\n",
        "            nn.Linear(128, 128), \n",
        "            nn.ReLU(), \n",
        "            nn.Linear(128, out_dim)\n",
        "        )\n",
        "\n",
        "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "        return self.layers(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ymr850fC8j5p"
      },
      "source": [
        "We can now declare a DQNAgent class for the OpenAI gym environment."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "eKeDjcgP8j5p"
      },
      "outputs": [],
      "source": [
        "class DQNAgent:\n",
        "    \"\"\"DQN Agent interacting with environment.\n",
        "    \n",
        "    Attribute:\n",
        "        env (gym.Env): openAI Gym environment\n",
        "        memory (ReplayBuffer): replay memory to store transitions\n",
        "        batch_size (int): batch size for sampling\n",
        "        epsilon (float): parameter for epsilon greedy policy\n",
        "        epsilon_decay (float): step size to decrease epsilon\n",
        "        max_epsilon (float): max value of epsilon\n",
        "        min_epsilon (float): min value of epsilon\n",
        "        target_update (int): period for target model's hard update\n",
        "        gamma (float): discount factor\n",
        "        dqn (Network): model to train and select actions\n",
        "        dqn_target (Network): target model to update\n",
        "        optimizer (torch.optim): optimizer for training dqn\n",
        "        transition (list): transition information including \n",
        "                           state, action, reward, next_state, done\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self, \n",
        "        env: gym.Env,\n",
        "        memory_size: int,\n",
        "        batch_size: int,\n",
        "        target_update: int,\n",
        "        epsilon_decay: float,\n",
        "        max_epsilon: float = 1.0,\n",
        "        min_epsilon: float = 0.1,\n",
        "        gamma: float = 0.99,\n",
        "    ):\n",
        "        \"\"\"Initialization.\n",
        "        \n",
        "        Args:\n",
        "            env (gym.Env): openAI Gym environment\n",
        "            memory_size (int): length of memory\n",
        "            batch_size (int): batch size for sampling\n",
        "            target_update (int): period for target model's hard update\n",
        "            epsilon_decay (float): step size to decrease epsilon\n",
        "            lr (float): learning rate\n",
        "            max_epsilon (float): max value of epsilon\n",
        "            min_epsilon (float): min value of epsilon\n",
        "            gamma (float): discount factor\n",
        "        \"\"\"\n",
        "        obs_dim = env.observation_space.shape[0]\n",
        "        action_dim = env.action_space.n\n",
        "        \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",
        "        \n",
        "        # device: cpu / gpu\n",
        "        self.device = torch.device(\n",
        "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "        )\n",
        "\n",
        "        # networks: dqn, dqn_target\n",
        "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
        "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
        "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
        "        self.dqn_target.eval()\n",
        "        \n",
        "        # optimizer\n",
        "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
        "\n",
        "        # transition to store in memory\n",
        "        self.transition = list()\n",
        "        \n",
        "        # mode: train / test\n",
        "        self.is_test = False\n",
        "\n",
        "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"Select an action from the input state.\"\"\"\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(self.device)\n",
        "            ).argmax()\n",
        "            selected_action = selected_action.detach().cpu().numpy()\n",
        "        \n",
        "        if not self.is_test:\n",
        "            self.transition = [state, selected_action]\n",
        "        \n",
        "        return selected_action\n",
        "\n",
        "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
        "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
        "        next_state, reward, done, _ = self.env.step(action)\n",
        "\n",
        "        if not self.is_test:\n",
        "            self.transition += [reward, next_state, done]\n",
        "            self.memory.store(*self.transition)\n",
        "    \n",
        "        return next_state, reward, done\n",
        "\n",
        "    def update_model(self) -> torch.Tensor:\n",
        "        \"\"\"Update the model by gradient descent.\"\"\"\n",
        "        samples = self.memory.sample_batch()\n",
        "\n",
        "        loss = self._compute_dqn_loss(samples)\n",
        "\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        self.optimizer.step()\n",
        "\n",
        "        return loss.item()\n",
        "        \n",
        "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
        "        \"\"\"Train the agent.\"\"\"\n",
        "        self.is_test = False\n",
        "        \n",
        "        state = self.env.reset()\n",
        "        update_cnt = 0\n",
        "        epsilons = []\n",
        "        losses = []\n",
        "        scores = []\n",
        "        score = 0\n",
        "\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",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "\n",
        "            # if episode ends\n",
        "            if done:\n",
        "                state = self.env.reset()\n",
        "                scores.append(score)\n",
        "                score = 0\n",
        "\n",
        "            # if ready to train\n",
        "            if len(self.memory) >= self.batch_size:\n",
        "                loss = self.update_model()\n",
        "                losses.append(loss)\n",
        "                update_cnt += 1\n",
        "                \n",
        "                # linearly decrease epsilon\n",
        "                self.epsilon = max(\n",
        "                    self.min_epsilon, self.epsilon - (\n",
        "                        self.max_epsilon - self.min_epsilon\n",
        "                    ) * self.epsilon_decay\n",
        "                )\n",
        "                epsilons.append(self.epsilon)\n",
        "                \n",
        "                # if hard update is needed\n",
        "                if update_cnt % self.target_update == 0:\n",
        "                    self._target_hard_update()\n",
        "\n",
        "            # plotting\n",
        "            if frame_idx % plotting_interval == 0:\n",
        "                self._plot(frame_idx, scores, losses, epsilons)\n",
        "                \n",
        "        self.env.close()\n",
        "                \n",
        "    def test(self) -> List[np.ndarray]:\n",
        "        \"\"\"Test the agent.\"\"\"\n",
        "        self.is_test = True\n",
        "        \n",
        "        state = self.env.reset()\n",
        "        done = False\n",
        "        score = 0\n",
        "        \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",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "        \n",
        "        print(\"score: \", score)\n",
        "        self.env.close()\n",
        "        \n",
        "        return frames\n",
        "\n",
        "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
        "        \"\"\"Return dqn loss.\"\"\"\n",
        "        device = self.device  # for shortening the following lines\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",
        "\n",
        "\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(self.device)\n",
        "\n",
        "        # calculate dqn loss\n",
        "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
        "\n",
        "        return loss\n",
        "\n",
        "    def _target_hard_update(self):\n",
        "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
        "                \n",
        "    def _plot(\n",
        "        self, \n",
        "        frame_idx: int, \n",
        "        scores: List[float], \n",
        "        losses: List[float], \n",
        "        epsilons: List[float],\n",
        "    ):\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": "markdown",
      "metadata": {
        "id": "r_cClVV-xgMi"
      },
      "source": [
        "There is a lot going on in the above class, so let's highlight a few things:     \n",
        "\n",
        "* The main method is `train`. \n",
        "* In each iteration of `train` we call the `step` method that performs the agent's action in the environment, updates the state, observes the reward, and stores the event in the replay buffer.\n",
        "* Action selection is done via the $\\varepsilon$-greedy policy. It is common to start with high $\\varepsilon$ (i.e., more exploration) in the beginning and gradually decay this value over time.\n",
        "* In the beginning we start with a clean slate (where our replay buffer, or the memory, is empty). Until we have enough \"experience\", no training happens.\n",
        "* Once we have gained enough experience, we are ready to train. This happens through `update_model` which is a standard backward pass through the DQN loss.\n",
        "* Observe that in `_compute_dqn_loss` we keep the *target* fixed (i.e., we don't update it) using `detach()`. To implement this we have a separate target variable `dqn_target`. For handling this we also have the  `_target_hard_update` method which updates the target occasionally."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uGmKOsy38j5r"
      },
      "source": [
        "## An example\n",
        "\n",
        "We will revisit our [Lunar Lander](https://www.gymlibrary.dev/environments/box2d/lunar_lander/) environment for which previously we had used policy gradients. This time, let us learn a policy using DQNs. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ln9YVUJ68j5s",
        "outputId": "4980783b-51dd-468d-b6d4-cfcfa4150981"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/gym/core.py:318: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n",
            "  \"Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\"\n",
            "/usr/local/lib/python3.7/dist-packages/gym/wrappers/step_api_compatibility.py:40: DeprecationWarning: \u001b[33mWARN: Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n",
            "  \"Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\"\n"
          ]
        }
      ],
      "source": [
        "# environment\n",
        "env_id = \"LunarLander-v2\"\n",
        "env = gym.make(env_id)\n",
        "\n",
        "num_frames = 20000\n",
        "memory_size = 1000\n",
        "batch_size = 32\n",
        "target_update = 100\n",
        "epsilon_decay = 1 / 2000\n",
        "\n",
        "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "636t2lom8j5t",
        "outputId": "3df35dbd-fd71-47d9-89ef-1afe496a0608"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1440x360 with 3 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "agent.train(num_frames)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G9AkQx_F1VHJ"
      },
      "source": [
        "As is evident from the plots, we start off with poor rewards but slowly learn to balance the pole as we gain more experience."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L9te-2RM8j5t"
      },
      "source": [
        "# Testing\n",
        "\n",
        "By now we should have learned a good policy. Let us see how well we do on a single episode."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4icgNT028j5t",
        "outputId": "d3ad2b03-1cbc-4357-d202-09628d74f5b2"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/gym/core.py:44: DeprecationWarning: \u001b[33mWARN: The argument mode in render method is deprecated; use render_mode during environment initialization instead.\n",
            "See here for more information: https://www.gymlibrary.ml/content/api/\u001b[0m\n",
            "  \"The argument mode in render method is deprecated; \"\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "score:  151.4763732210524\n",
            "There are 860 frames.\n"
          ]
        }
      ],
      "source": [
        "frames = agent.test()\n",
        "\n",
        "print(f'There are {len(frames)} frames.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pIPPA1ed1Rvh"
      },
      "source": [
        "Seems like we have done quite well! Try implementing this with other Gym environments, other Q-networks, and with greater/lesser replay buffer size."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "ECgP3W8DzmGI",
        "outputId": "b81372cb-55b9-4025-b0fa-39b63ab4d551"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "for frame_idx in range(len(frames)):\n",
        "  plt.imshow(frames[frame_idx])\n",
        "  plt.show()\n",
        "  clear_output(True)\n",
        "  "
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "demo10.ipynb",
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3.10.0 64-bit ('3.10.0')",
      "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.10.0"
    },
    "vscode": {
      "interpreter": {
        "hash": "6aea8d84a86a1280a34780710c5e478b9c6b3c016841b907182e7484363820b1"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}