04.dueling.ipynb

{
 "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": [
    "# 04. Dueling Network\n",
    "\n",
    "[Z. Wang et al., \"Dueling Network Architectures for Deep Reinforcement Learning.\" arXiv preprint arXiv:1511.06581, 2015.](https://arxiv.org/pdf/1511.06581.pdf)\n",
    "\n",
    "The proposed network architecture, which is named *dueling architecture*, explicitly separates the representation of state values and (state-dependent) action advantages. \n",
    "\n",
    "![fig1](https://user-images.githubusercontent.com/14961526/60322956-c2f0b600-99bb-11e9-9ed4-443bd14bc3b0.png)\n",
    "\n",
    "The dueling network automatically produces separate estimates of the state value function and advantage function, without any extra supervision. Intuitively, the dueling architecture can learn which states are (or are not) valuable, without having to learn the effect of each action for each state. This is particularly useful in states where its actions do not affect the environment in any relevant way. \n",
    "\n",
    "The dueling architecture represents both the value $V(s)$ and advantage $A(s, a)$ functions with a single deep model whose output combines the two to produce a state-action value $Q(s, a)$. Unlike in advantage updating, the representation and algorithm are decoupled by construction.\n",
    "\n",
    "$$A^\\pi (s, a) = Q^\\pi (s, a) - V^\\pi (s).$$\n",
    "\n",
    "The value function $V$ measures the how good it is to be in a particular state $s$. The $Q$ function, however, measures the the value of choosing a particular action when in this state. Now, using the definition of advantage, we might be tempted to construct the aggregating module as follows:\n",
    "\n",
    "$$Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + A(s, a; \\theta, \\alpha),$$\n",
    "\n",
    "where $\\theta$ denotes the parameters of the convolutional layers, while $\\alpha$ and $\\beta$ are the parameters of the two streams of fully-connected layers.\n",
    "\n",
    "Unfortunately, the above equation is unidentifiable in the sense that given $Q$ we cannot recover $V$ and $A$ uniquely; for example, there are uncountable pairs of $V$ and $A$ that make $Q$ values to zero. To address this issue of identifiability, we can force the advantage function estimator to have zero advantage at the chosen action. That is, we let the last module of the network implement the forward mapping.\n",
    "\n",
    "$$\n",
    "Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + \\big( A(s, a; \\theta, \\alpha) - \\max_{a' \\in |\\mathcal{A}|} A(s, a'; \\theta, \\alpha) \\big).\n",
    "$$\n",
    "\n",
    "This formula guarantees that we can recover the unique $V$ and $A$, but the optimization is not so stable because the advantages have to compensate any change to the optimal action’s advantage. Due to the reason, an alternative module that replaces the max operator with an average is proposed:\n",
    "\n",
    "$$\n",
    "Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + \\big( A(s, a; \\theta, \\alpha) - \\frac{1}{|\\mathcal{A}|} \\sum_{a'} A(s, a'; \\theta, \\alpha) \\big).\n",
    "$$\n",
    "\n",
    "Unlike the max advantage form, in this formula, the advantages only need to change as fast as the mean, so it increases the stability of optimization."
   ]
  },
  {
   "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\n",
    "from torch.nn.utils import clip_grad_norm_"
   ]
  },
  {
   "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": [
    "## Dueling Network\n",
    "\n",
    "Carefully take a look at advantage and value layers separated from feature layer."
   ]
  },
  {
   "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",
    "        # set common feature layer\n",
    "        self.feature_layer = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        # set advantage layer\n",
    "        self.advantage_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, out_dim),\n",
    "        )\n",
    "\n",
    "        # set value layer\n",
    "        self.value_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 1),\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        feature = self.feature_layer(x)\n",
    "        \n",
    "        value = self.value_layer(feature)\n",
    "        advantage = self.advantage_layer(feature)\n",
    "\n",
    "        q = value + advantage - advantage.mean(dim=-1, keepdim=True)\n",
    "        \n",
    "        return q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN + DuelingNet Agent (w/o Double-DQN & PER)\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",
    "\n",
    "Aside from the dueling network architecture, the authors suggest to use Double-DQN and Prioritized Experience Replay as extra components for better performance. However, we don't implement them to simplify the tutorial. There is only one diffrence between DQNAgent here and the one from *01.dqn.ipynb* and that is the usage of clip_grad_norm_ to prevent gradient exploding."
   ]
  },
  {
   "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",
    "    ):\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",
    "        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",
    "        \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",
    "        # DuelingNet: we clip the gradients to have their norm less than or equal to 10.\n",
    "        clip_grad_norm_(self.dqn.parameters(), 10.0)\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",
    "    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",
    "        # 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(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[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",
    "        \"\"\"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",
    "# 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/dueling\"\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/dueling/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
}