dl_demo10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.7.9"
    },
    "colab": {
      "name": "demo10.ipynb",
      "provenance": []
    }
  },
  "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",
      "metadata": {
        "id": "H2Hubctq8j5h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae02211b-f08f-4edb-b09b-646dc9dbad8f"
      },
      "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",
        "    from pyvirtualdisplay import Display\n",
        "    \n",
        "    # Start virtual display\n",
        "    dis = Display(visible=0, size=(400, 400))\n",
        "    dis.start()"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "Suggested packages:\n",
            "  libgle3\n",
            "The following NEW packages will be installed:\n",
            "  python-opengl\n",
            "0 upgraded, 1 newly installed, 0 to remove and 37 not upgraded.\n",
            "Need to get 496 kB of archives.\n",
            "After this operation, 5,416 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic/universe amd64 python-opengl all 3.1.0+dfsg-1 [496 kB]\n",
            "Fetched 496 kB in 2s (253 kB/s)\n",
            "Selecting previously unselected package python-opengl.\n",
            "(Reading database ... 155222 files and directories currently installed.)\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 python-opengl (3.1.0+dfsg-1) ...\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "ffmpeg is already the newest version (7:3.4.8-0ubuntu0.2).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 37 not upgraded.\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following NEW packages will be installed:\n",
            "  xvfb\n",
            "0 upgraded, 1 newly installed, 0 to remove and 37 not upgraded.\n",
            "Need to get 784 kB of archives.\n",
            "After this operation, 2,270 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.9 [784 kB]\n",
            "Fetched 784 kB in 2s (383 kB/s)\n",
            "Selecting previously unselected package xvfb.\n",
            "(Reading database ... 157577 files and directories currently installed.)\n",
            "Preparing to unpack .../xvfb_2%3a1.19.6-1ubuntu4.9_amd64.deb ...\n",
            "Unpacking xvfb (2:1.19.6-1ubuntu4.9) ...\n",
            "Setting up xvfb (2:1.19.6-1ubuntu4.9) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Collecting pyvirtualdisplay\n",
            "  Downloading PyVirtualDisplay-2.2-py3-none-any.whl (15 kB)\n",
            "Collecting EasyProcess\n",
            "  Downloading EasyProcess-0.3-py2.py3-none-any.whl (7.9 kB)\n",
            "Installing collected packages: EasyProcess, pyvirtualdisplay\n",
            "Successfully installed EasyProcess-0.3 pyvirtualdisplay-2.2\n",
            "Requirement already satisfied: gym in /usr/local/lib/python3.7/dist-packages (0.17.3)\n",
            "Requirement already satisfied: numpy>=1.10.4 in /usr/local/lib/python3.7/dist-packages (from gym) (1.19.5)\n",
            "Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.3.0)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from gym) (1.4.1)\n",
            "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.5.0)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from pyglet<=1.5.0,>=1.4.0->gym) (0.16.0)\n"
          ]
        }
      ]
    },
    {
      "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",
      "metadata": {
        "id": "FwGedGkQ8j5n"
      },
      "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"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "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",
      "metadata": {
        "id": "CurGtu8g8j5o"
      },
      "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"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "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",
      "metadata": {
        "id": "xJvllA4o8j5o"
      },
      "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)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ymr850fC8j5p"
      },
      "source": [
        "We can now declare a DQNAgent class for the OpenAI gym environment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKeDjcgP8j5p"
      },
      "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()"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "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 [CartPole](https://gym.openai.com/envs/CartPole-v0/) environment for which previously we had used policy gradients. This time, let us learn a policy using DQNs. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ln9YVUJ68j5s"
      },
      "source": [
        "# environment\n",
        "env_id = \"CartPole-v0\"\n",
        "env = gym.make(env_id)\n",
        "if IN_COLAB:\n",
        "    env = gym.wrappers.Monitor(env, \"videos\", force=True)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QzxwJvqx8j5s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "86484018-d17f-4c7a-d4a5-6639972c7458"
      },
      "source": [
        "seed = 777\n",
        "\n",
        "def seed_torch(seed):\n",
        "    torch.manual_seed(seed)\n",
        "    if torch.backends.cudnn.enabled:\n",
        "        torch.backends.cudnn.benchmark = False\n",
        "        torch.backends.cudnn.deterministic = True\n",
        "\n",
        "np.random.seed(seed)\n",
        "seed_torch(seed)\n",
        "env.seed(seed)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[777]"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fT50wv2T8j5s"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Htwr-9BS8j5t"
      },
      "source": [
        "# parameters\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)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "636t2lom8j5t",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 310
        },
        "outputId": "28f49697-2c47-4fcb-9403-cfbb43f55e88"
      },
      "source": [
        "agent.train(num_frames)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 3 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "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",
      "metadata": {
        "id": "4icgNT028j5t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "83782452-4ee6-4cf6-b368-160be150bfb0"
      },
      "source": [
        "frames = agent.test()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "score:  200.0\n"
          ]
        }
      ]
    },
    {
      "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."
      ]
    }
  ]
}