01.dqn.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": [
    "# 01. DQN\n",
    "\n",
    "[V. Mnih et al., \"Human-level control through deep reinforcement learning.\" Nature, 518\n",
    "(7540):529–533, 2015.](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)\n",
    "\n",
    "Reinforcement learning is known to be unstable or even to diverge when a nonlinear function approximator such as a neural network is used to represent the action-value (also known as $Q$) function. This instability has several causes: the correlations present in the sequence of observations, the fact that small updates to $Q$ may significantly change the policy and therefore change the data distribution, and the correlations between the action-values ($Q$) and the target values $r + \\gamma \\max_{a'} Q(s', a')$.\n",
    "\n",
    "The authors suggest two key ideas to address these instabilities with a novel variant of Q-learning: Replay buffer and Fixed Q-target.\n",
    "\n",
    "#### Uniformly random sampling from Experience Replay Memory\n",
    "\n",
    "Reinforcement learning agent stores the experiences consecutively in the buffer, so adjacent ($s, a, r, s'$) transitions stored are highly likely to have correlation. To remove this, the agent samples experiences uniformly at random from the pool of stored samples $\\big( (s, a, r, s') \\sim U(D) \\big)$. See sample_batch method of ReplayBuffer class for more details.\n",
    "\n",
    "#### Fixed Q-target\n",
    "\n",
    "DQN uses an iterative update that adjusts the action-values ($Q$) towards target values that are only periodically updated, thereby reducing correlations with the target; if not, it is easily divergy because the target continuously moves. The Q-learning update at iteration $i$ uses the following loss function:\n",
    "\n",
    "$$\n",
    "L_i(\\theta_i) = \\mathbb{E}_{(s,a,r,s') \\sim U(D)} \\big[ \\big( r + \\gamma \\max_{a'} Q(s',a';\\theta_i^-) - Q(s, a; \\theta_i) \\big)^2 \\big]\n",
    "$$\n",
    "\n",
    "in which $\\gamma$ is the discount factor determining the agent’s horizon, $\\theta_i$ are the parameters of the Q-network at iteration $i$ and $\\theta_i^-$ are the network parameters used to compute the target at iteration $i$. The target network parameters $\\theta_i^-$ are only updated with the Q-network parameters ($\\theta_i$) every C steps and are held fixed between individual updates. ($C = 200$ in CartPole-v0)\n",
    "\n",
    "#### For more stability: Gradient clipping\n",
    "\n",
    "The authors also found it helpful to clip the error term from the update $r + \\gamma \\max_{a'} Q(s', a'; \\theta_i^-) - Q(s,a,;\\theta_i)$ to be between -1 and 1. Because the absolute value loss function $|x|$ has a derivative of -1 for all negative values of x and a derivative of 1 for all positive values of x, clipping the squared error to be between -1 and 1 corresponds to using an absolute value loss function for errors outside of the (-1,1) interval. This form of error clipping further improved the stability of the algorithm."
   ]
  },
  {
   "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",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "  - collections.deque\n",
    "  - list\n",
    "  - numpy.ndarray\n",
    "  \n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of  *Get item* is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference). Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "\n",
    "Reference: [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "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",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "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)"
   ]
  },
  {
   "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",
    "    ):\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",
    "        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(\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",
    "        \"\"\"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)"
   ]
  },
  {
   "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 = 10000\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:  200.0\n"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/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/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
}