{
 "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==3.0\n",
    "    !pip install gym==0.21.0\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": [
    "# 06. Categorical DQN\n",
    "\n",
    "[M. G. Bellemare et al., \"A Distributional Perspective on Reinforcement Learning.\" arXiv preprint arXiv:1707.06887, 2017.](https://arxiv.org/pdf/1707.06887.pdf)\n",
    "\n",
    "The authors argued the importance of learning the distribution of returns instead of the expected return, and they proposed to model such distributions with probability masses placed on a discrete support $z$, where $z$ is a vector with $N_{atoms} \\in \\mathbb{N}^+$ atoms, defined by $z_i = V_{min} + (i-1) \\frac{V_{max} - V_{min}}{N-1}$ for $i \\in \\{1, ..., N_{atoms}\\}$.\n",
    "\n",
    "The key insight is that return distributions satisfy a variant of Bellman’s equation. For a given state $S_t$ and action $A_t$, the distribution of the returns under the optimal policy $\\pi^{*}$ should match a target distribution defined by taking the distribution for the next state $S_{t+1}$ and action $a^{*}_{t+1} = \\pi^{*}(S_{t+1})$, contracting\n",
    "it towards zero according to the discount, and shifting it by the reward (or distribution of rewards, in the stochastic case). A distributional variant of Q-learning is then derived by first constructing a new support for the target distribution, and then minimizing the Kullbeck-Leibler divergence between the distribution $d_t$ and the target distribution\n",
    "\n",
    "$$\n",
    "d_t' = (R_{t+1} + \\gamma_{t+1} z, p_\\hat{{\\theta}} (S_{t+1}, \\hat{a}^{*}_{t+1})),\\\\\n",
    "D_{KL} (\\phi_z d_t' \\| d_t).\n",
    "$$\n",
    "\n",
    "Here $\\phi_z$ is a L2-projection of the target distribution onto the fixed support $z$, and $\\hat{a}^*_{t+1} = \\arg\\max_{a} q_{\\hat{\\theta}} (S_{t+1}, a)$ is the greedy action with respect to the mean action values $q_{\\hat{\\theta}} (S_{t+1}, a) = z^{T}p_{\\theta}(S_{t+1}, a)$ in state $S_{t+1}$."
   ]
  },
  {
   "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": [
    "## Network\n",
    "\n",
    "The parametrized distribution can be represented by a neural network, as in DQN, but with atom_size x out_dim outputs. A softmax is applied independently for each action dimension of the output to ensure that the distribution for each action is appropriately normalized.\n",
    "\n",
    "To estimate q-values, we use inner product of each action's softmax distribution and support which is the set of atoms $\\{z_i = V_{min} + i\\Delta z: 0 \\le i < N\\}, \\Delta z = \\frac{V_{max} - V_{min}}{N-1}$.\n",
    "\n",
    "$$\n",
    "Q(s_t, a_t) = \\sum_i z_i p_i(s_t, a_t), \\\\\n",
    "\\text{where } p_i \\text{ is the probability of } z_i \\text{ (the output of softmax)}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        atom_size: int, \n",
    "        support: torch.Tensor\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.support = support\n",
    "        self.out_dim = out_dim\n",
    "        self.atom_size = atom_size\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 * atom_size)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        dist = self.dist(x)\n",
    "        q = torch.sum(dist * self.support, dim=2)\n",
    "        \n",
    "        return q\n",
    "    \n",
    "    def dist(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Get distribution for atoms.\"\"\"\n",
    "        q_atoms = self.layers(x).view(-1, self.out_dim, self.atom_size)\n",
    "        dist = F.softmax(q_atoms, dim=-1)\n",
    "        dist = dist.clamp(min=1e-3)  # for avoiding nans\n",
    "        \n",
    "        return dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical DQN Agent\n",
    "\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",
    "\n",
    "All differences from pure DQN are noted with comments *Categorical DQN*."
   ]
  },
  {
   "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",
    "        v_min (float): min value of support\n",
    "        v_max (float): max value of support\n",
    "        atom_size (int): the unit number of support\n",
    "        support (torch.Tensor): support for categorical dqn\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",
    "        # Categorical DQN parameters\n",
    "        v_min: float = 0.0,\n",
    "        v_max: float = 200.0,\n",
    "        atom_size: int = 51,\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",
    "            v_min (float): min value of support\n",
    "            v_max (float): max value of support\n",
    "            atom_size (int): the unit number of support\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(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "        \n",
    "        # Categorical DQN parameters\n",
    "        self.v_min = v_min\n",
    "        self.v_max = v_max\n",
    "        self.atom_size = atom_size\n",
    "        self.support = torch.linspace(\n",
    "            self.v_min, self.v_max, self.atom_size\n",
    "        ).to(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).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 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, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\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",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return categorical 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\"]).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",
    "        # Categorical DQN algorithm\n",
    "        delta_z = float(self.v_max - self.v_min) / (self.atom_size - 1)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            next_action = self.dqn_target(next_state).argmax(1)\n",
    "            next_dist = self.dqn_target.dist(next_state)\n",
    "            next_dist = next_dist[range(self.batch_size), next_action]\n",
    "\n",
    "            t_z = reward + (1 - done) * self.gamma * self.support\n",
    "            t_z = t_z.clamp(min=self.v_min, max=self.v_max)\n",
    "            b = (t_z - self.v_min) / delta_z\n",
    "            l = b.floor().long()\n",
    "            u = b.ceil().long()\n",
    "\n",
    "            offset = (\n",
    "                torch.linspace(\n",
    "                    0, (self.batch_size - 1) * self.atom_size, self.batch_size\n",
    "                ).long()\n",
    "                .unsqueeze(1)\n",
    "                .expand(self.batch_size, self.atom_size)\n",
    "                .to(self.device)\n",
    "            )\n",
    "\n",
    "            proj_dist = torch.zeros(next_dist.size(), device=self.device)\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (l + offset).view(-1), (next_dist * (u.float() - b)).view(-1)\n",
    "            )\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (u + offset).view(-1), (next_dist * (b - l.float())).view(-1)\n",
    "            )\n",
    "\n",
    "        dist = self.dqn.dist(state)\n",
    "        log_p = torch.log(dist[range(self.batch_size), action])\n",
    "\n",
    "        loss = -(proj_dist * log_p).sum(1).mean()\n",
    "\n",
    "        return loss\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 = 2000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\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:  200.0\n"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/categorical_dqn\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/categorical_dqn/rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "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 width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}