From 70a92ae5b828f229a32783b21f6b2d5d130a1fe4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=91=A8=E8=B6=85?= <zc98770@alibaba-inc.com>
Date: Wed, 7 Jul 2021 20:36:06 +0800
Subject: [PATCH] curiosity

---
 11.curiosity.ipynb | 723 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 723 insertions(+)
 create mode 100644 11.curiosity.ipynb

diff --git a/11.curiosity.ipynb b/11.curiosity.ipynb
new file mode 100644
index 0000000..9cd109b
--- /dev/null
+++ b/11.curiosity.ipynb
@@ -0,0 +1,723 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Configurations for Colab"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "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()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 11. Curiosity\n",
+    "\n",
+    "[Deepak Pathak, Pulkit Agrawal, Alexei A. Efros and Trevor Darrell. Curiosity-driven Exploration by Self-supervised Prediction.\n",
+    "In ICML 2017.](https://pathak22.github.io/noreward-rl/resources/icml17.pdf)\n",
+    "\n",
+    "\n",
+    "\n",
+    "In many real-world scenarios, rewards extrinsic to the agent are extremely sparse, or absent altogether. In such cases, curiosity can serve as an intrinsic reward signal to enable the agent to explore its environment and learn skills that might be useful later in its life. We formulate curiosity as the error in an agent's ability to predict the consequence of its own actions in a visual feature space learned by a self-supervised inverse dynamics model. Our formulation scales to high-dimensional continuous state spaces like images, bypasses the difficulties of directly predicting pixels, and, critically, ignores the aspects of the environment that cannot affect the agent. The proposed approach is evaluated in two environments: VizDoom and Super Mario Bros. Three broad settings are investigated: 1) sparse extrinsic reward, where curiosity allows for far fewer interactions with the environment to reach the goal; 2) exploration with no extrinsic reward, where curiosity pushes the agent to explore more efficiently; and 3) generalization to unseen scenarios (e.g. new levels of the same game) where the knowledge gained from earlier experience helps the agent explore new places much faster than starting from scratch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "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": {},
+   "source": [
+    "## Replay buffer\n",
+    "\n",
+    "Please see *01.dqn.ipynb* for detailed description."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "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": {},
+   "source": [
+    "## Curiosity Network\n",
+    "\n",
+    "Intrinsic Curiosity Module (ICM)\n",
+    "We propose intrinsic curiosity formulation to help agent exploration. Curiosity help agent discover the environment out of curiosity when extrinsic rewards are spare or not present at all. Our proposed intrinsic model (ICM) is learned jointly with agent's policy even without any rewards from the environment. A glimpse of our model is shown in figure below. For more details, refer to the paper.\n",
+    "![ICM](https://pathak22.github.io/noreward-rl/resources/method.jpg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "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",
+    "        \"\"\"Forward method implementation.\"\"\"\n",
+    "        return self.layers(x)\n",
+    "\n",
+    "\n",
+    "class ICM(nn.Module):\n",
+    "    def __init__(self, in_dim: int, out_dim: int):\n",
+    "        \"\"\"Initialization.\"\"\"\n",
+    "        super(ICM, self).__init__()\n",
+    "\n",
+    "        self.fea_layers = nn.Sequential(\n",
+    "            nn.Linear(in_dim, 128), \n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(128, 128), \n",
+    "            nn.ReLU()\n",
+    "        )\n",
+    "        \n",
+    "        self.pred_module1 = nn.Linear(128 + out_dim, 128)\n",
+    "        self.pred_module2 = nn.Linear(128, 128)\n",
+    "            \n",
+    "        self.invpred_module1 = nn.Linear(128 + 128, 128)\n",
+    "        self.invpred_module2 = nn.Linear(128, out_dim)\n",
+    "        \n",
+    "    def pred(self, feature_x, a_vec):\n",
+    "        # Forward prediction: predict next state feature, given current state feature and action (one-hot)\n",
+    "        pred_s_next = F.relu(self.pred_module1( torch.cat([feature_x, a_vec.float()], dim = -1).detach()))\n",
+    "        pred_s_next = self.pred_module2(pred_s_next)\n",
+    "        return pred_s_next\n",
+    "    \n",
+    "    def invpred(self, feature_x, feature_x_next):\n",
+    "        # Inverse prediction: predict action (one-hot), given current and next state features\n",
+    "        pred_a_vec = F.relu(self.invpred_module1(torch.cat([feature_x, feature_x_next], dim = -1)))\n",
+    "        pred_a_vec = self.invpred_module2(pred_a_vec)\n",
+    "        return F.softmax(pred_a_vec, dim = -1)\n",
+    "\n",
+    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
+    "        \"\"\"Forward method implementation.\"\"\"\n",
+    "        return self.fea_layers(x)\n",
+    "\n",
+    "    def get_full(self, x, x_next, a_vec):\n",
+    "        # get feature\n",
+    "        feature_x = self.fea_layers(x)\n",
+    "        feature_x_next = self.fea_layers(x_next)\n",
+    "\n",
+    "        pred_s_next = self.pred(feature_x, a_vec) # predict next state feature\n",
+    "        pred_a_vec = self.invpred(feature_x, feature_x_next) # (inverse) predict action\n",
+    "\n",
+    "        return pred_s_next, pred_a_vec, feature_x_next"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## DQN Agent\n",
+    "\n",
+    "Here is a summary of DQNAgent class.\n",
+    "\n",
+    "| Method           | Note                                                 |\n",
+    "| ---              | ---                                                  |\n",
+    "|select_action     | select an action from the input state.               |\n",
+    "|step              | take an action and return the response of the env.   |\n",
+    "|compute_dqn_loss  | return dqn loss.                                     |\n",
+    "|update_model      | update the model by gradient descent.                |\n",
+    "|target_hard_update| hard update from the local model to the target model.|\n",
+    "|train             | train the agent during num_frames.                   |\n",
+    "|test              | test the agent (1 episode).                          |\n",
+    "|plot              | plot the training progresses.                        |\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "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",
+    "        use_extrinsic: bool = True,\n",
+    "        intrinsic_scale: float = 1.0,\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",
+    "        self.use_extrinsic = use_extrinsic\n",
+    "        self.intrinsic_scale = intrinsic_scale\n",
+    "        \n",
+    "        # device: cpu / gpu\n",
+    "        self.device = torch.device(\n",
+    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "        )\n",
+    "        print(self.device)\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",
+    "        self.icm = ICM(obs_dim, action_dim).to(self.device)\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 training is ready\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",
+    "        a_vec = F.one_hot(action, num_classes = self.env.action_space.n).reshape(-1,self.env.action_space.n) # convert action from int to one-hot format\n",
+    "        pred_s_next, pred_a_vec, feature_x_next = self.icm.get_full(state, next_state, a_vec)\n",
+    "        forward_loss = F.mse_loss(pred_s_next, feature_x_next, reduction='none')\n",
+    "        inverse_pred_loss = F.cross_entropy(pred_a_vec, action.reshape(-1), reduction='none')\n",
+    "        \n",
+    "        # calculate rewards\n",
+    "        intrinsic_reward = self.intrinsic_scale * forward_loss.mean(-1)\n",
+    "        total_reward = intrinsic_reward.clone().reshape(-1,1)\n",
+    "        if self.use_extrinsic:\n",
+    "            total_reward += reward\n",
+    "\n",
+    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
+    "        #       = r                       otherwise\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 = (total_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 + forward_loss.mean() + inverse_pred_loss.mean()\n",
+    "\n",
+    "    def _target_hard_update(self):\n",
+    "        \"\"\"Hard update: target <- local.\"\"\"\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": {},
+   "source": [
+    "## Environment\n",
+    "\n",
+    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "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)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set random seed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[777]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initialize"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cpu\n"
+     ]
+    }
+   ],
+   "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)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "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": {},
+   "source": [
+    "## Test\n",
+    "\n",
+    "Run the trained agent (1 episode)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "score:  17.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "frames = agent.test()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Render"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'JSAnimation'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-11-ef9f48556d47>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# for jupyter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m     \u001b[0;32mfrom\u001b[0m \u001b[0mmatplotlib\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0manimation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 33\u001b[0;31m     \u001b[0;32mfrom\u001b[0m \u001b[0mJSAnimation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIPython_display\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdisplay_animation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     34\u001b[0m     \u001b[0;32mfrom\u001b[0m \u001b[0mIPython\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdisplay\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdisplay\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'JSAnimation'"
+     ]
+    }
+   ],
+   "source": [
+    "if IN_COLAB:  # for colab\n",
+    "    import base64\n",
+    "    import glob\n",
+    "    import io\n",
+    "    import os\n",
+    "\n",
+    "    from IPython.display import HTML, display\n",
+    "\n",
+    "\n",
+    "    def ipython_show_video(path: str) -> None:\n",
+    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
+    "        if not os.path.isfile(path):\n",
+    "            raise NameError(\"Cannot access: {}\".format(path))\n",
+    "\n",
+    "        video = io.open(path, \"r+b\").read()\n",
+    "        encoded = base64.b64encode(video)\n",
+    "\n",
+    "        display(HTML(\n",
+    "            data=\"\"\"\n",
+    "            <video alt=\"test\" controls>\n",
+    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
+    "            </video>\n",
+    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
+    "        ))\n",
+    "\n",
+    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
+    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
+    "    print(latest_file)\n",
+    "    ipython_show_video(latest_file)\n",
+    "    \n",
+    "else:  # for jupyter\n",
+    "    from matplotlib import animation\n",
+    "    from JSAnimation.IPython_display import display_animation\n",
+    "    from IPython.display import display\n",
+    "\n",
+    "\n",
+    "    def display_frames_as_gif(frames: List[np.ndarray]) -> None:\n",
+    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
+    "        patch = plt.imshow(frames[0])\n",
+    "        plt.axis('off')\n",
+    "\n",
+    "        def animate(i):\n",
+    "            patch.set_data(frames[i])\n",
+    "\n",
+    "        anim = animation.FuncAnimation(\n",
+    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
+    "        )\n",
+    "        display(display_animation(anim, default_mode='loop'))\n",
+    "\n",
+    "\n",
+    "    # display \n",
+    "    display_frames_as_gif(frames)"
+   ]
+  }
+ ],
+ "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.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}