02.double_q.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 gymnasium==0.28.1\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": [
    "# 02. Double DQN\n",
    "\n",
    "[van Hasselt et al., \"Deep Reinforcement Learning with Double Q-learning.\" arXiv preprint arXiv:1509.06461, 2015.](https://arxiv.org/pdf/1509.06461.pdf)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Let's take a close look at the difference between DQN and Double-DQN. The max operator in standard Q-learning and DQN uses the same values both to select and to evaluate an action. This makes it more likely to select overestimated values, resulting in overoptimistic value estimates.\n",
    "\n",
    "$$\n",
    "\\theta_{t+1} = \\theta_t + \\alpha \\big(Y_t^Q - Q(S_t, A_t; \\theta_t)\\big) \\cdot \\nabla_{\\theta_t} Q(S_t, A_t; \\theta_t),\\\\\n",
    "\\text{where } \\alpha \\text{ is a scalar step size and the target } Y_t^Q \\text{is defined as }\\\\\n",
    "Y_t^Q = R_{t+1} + \\gamma \\max_a Q(S_{t+1}, a; \\theta_t).\n",
    "$$\n",
    "\n",
    "In Double Q-learning ([van Hasselt 2010](https://papers.nips.cc/paper/3964-double-q-learning.pdf)), two value functions are learned by assigning experiences randomly to update one of the two value functions, resulting in two sets of weights, $\\theta$ and $\\theta'$. For each update, one set of weights is used to determine the greedy policy and the other to determine its value. For a clear comparison, we can untangle the selection and evaluation in Q-learning and rewrite DQN's target as\n",
    "\n",
    "$$\n",
    "Y_t^Q = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t).\n",
    "$$\n",
    "\n",
    "The Double Q-learning error can then be written as\n",
    "\n",
    "$$\n",
    "Y_t^{DoubleQ} = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t').\n",
    "$$\n",
    "\n",
    "The idea of Double Q-learning is to reduce overestimations by decomposing the max operation in the target into action selection and action evaluation. Although not fully decoupled, the target network in the DQN architecture provides a natural candidate for the second value function, without having to introduce additional networks. In conclusion, the weights of the second network $\\theta_t'$ are replaced with the weights of the target network for the evaluation of the current greedy policy. This makes just a small change in calculating the target value of DQN loss.\n",
    "\n",
    "##### DQN:\n",
    "\n",
    "```\n",
    "target = reward + gamma * dqn_target(next_state).max(dim=1, keepdim=True)[0]\n",
    "```\n",
    "\n",
    "##### DoubleDQN:\n",
    "\n",
    "```\n",
    "selected_action = dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "target = reward + gamma * dqn_target(next_state).gather(1, selected_action)\n",
    "```\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jinwoo.park/miniforge3/envs/rainbow-is-all-you-need/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as 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",
    "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": [
    "## Double 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",
    "\n",
    "We use `self.dqn` instead of `self.dqn_target` for action selection.\n",
    "\n",
    "```\n",
    "\n",
    "        next_q_value = self.dqn_target(next_state).gather(\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)  # Double DQN\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\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",
    "        seed: int,\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.seed = seed\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, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\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(seed=self.seed)\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(seed=self.seed)\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(seed=self.seed)\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).gather(  # Double DQN\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "        ).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/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(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 = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "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": [
      "Moviepy - Building video /Users/jinwoo.park/Repositories/rainbow-is-all-you-need/videos/double_q/rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video /Users/jinwoo.park/Repositories/rainbow-is-all-you-need/videos/double_q/rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                               "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /Users/jinwoo.park/Repositories/rainbow-is-all-you-need/videos/double_q/rl-video-episode-0.mp4\n",
      "score:  170.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/double_q\"\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/double_q/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": "rainbow-is-all-you-need",
   "language": "python",
   "name": "rainbow-is-all-you-need"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}