01.A2C.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r6M92YNE9Nna"
      },
      "source": [
        "## Configuration for Colab"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "GyYmCpH89Nnb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37fd42e2-9619-4eb9-f69c-b018c7e979ec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting gymnasium==1.0.0\n",
            "  Downloading gymnasium-1.0.0-py3-none-any.whl.metadata (9.5 kB)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (1.26.4)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (3.1.0)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (4.12.2)\n",
            "Collecting farama-notifications>=0.0.1 (from gymnasium==1.0.0)\n",
            "  Downloading Farama_Notifications-0.0.4-py3-none-any.whl.metadata (558 bytes)\n",
            "Downloading gymnasium-1.0.0-py3-none-any.whl (958 kB)\n",
            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/958.1 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m307.2/958.1 kB\u001b[0m \u001b[31m9.9 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m958.1/958.1 kB\u001b[0m \u001b[31m15.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n",
            "Installing collected packages: farama-notifications, gymnasium\n",
            "Successfully installed farama-notifications-0.0.4 gymnasium-1.0.0\n"
          ]
        }
      ],
      "source": [
        "import sys\n",
        "\n",
        "IN_COLAB = \"google.colab\" in sys.modules\n",
        "\n",
        "if IN_COLAB:\n",
        "    !pip install gymnasium==1.0.0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bkcr9XKc9Nnc"
      },
      "source": [
        "## 01. A2C\n",
        "[Mnih, Volodymyr, et al. \"Asynchronous methods for deep reinforcement learning.\" International conference on machine learning. 2016.](http://proceedings.mlr.press/v48/mniha16.pdf)\n",
        "\n",
        "### Actor-Critic\n",
        "\n",
        "*Actor critic* method is one of the popular *policy optimization* algorithms. This approach maximizes the expected return by pushing up the probabilities of actions that receive higher returns. Let $\\pi_\\theta$ denote a policy with parameters $\\theta$. The policy gradient of performance $\\mathcal{J}(\\pi_\\theta)$ is\n",
        "\n",
        "$$ \\nabla_\\theta \\mathcal{J}(\\pi_\\theta) = \\underset{\\tau\\sim\\pi_\\theta}{\\mathbb{E}}\\left[ \\sum^T_{t=0} \\nabla_\\theta \\log \\pi_\\theta(a_t|s_t)A^{\\pi_\\theta}(s_t, a_t) \\right],$$\n",
        "\n",
        "where $\\tau$ is a trajectory and $A^{\\pi_\\theta}$ is the advantage function for reducing variance of values. The *policy gradient algorithm* updates the parameters by adding this gradient.\n",
        "\n",
        "$$\\theta_{k+1} = \\theta_k + \\alpha \\nabla_\\theta \\mathcal{J}(\\pi_{\\theta_k}),$$\n",
        "\n",
        "where $\\alpha$ is a learning rate. The agent is trained in an on-policy way because the parameters are updated by the current policy. We call the policy *Actor* which predicts probabilities of actions in each state, and call the value function *Critic* that predicts values of all state-action pairs.\n",
        "\n",
        "\n",
        "### Advantage Function\n",
        "\n",
        "The advantage function effectively reduces the variance of values and is defined as follows.\n",
        "\n",
        "$$ A(s,a) = Q(s,a) - V(s) $$\n",
        "\n",
        "From this formula, we can replace Q with $r+\\gamma V(s')$ and redefine Advantage function without using Action-Value function.\n",
        "\n",
        "$$ A(s,a) = r + \\gamma V(s') - V(s) $$\n",
        "\n",
        "\n",
        "### Maximization Entropy\n",
        "\n",
        "Entropy is a measure of unpredictability or a measure of randomness. If we have actions with almost equal probabilities, the entropy over the actions will be the largest because it's completely unpredictable which action will be chosen. In view of the fact, we can encourage exploration by adding entropy maximization term to the loss function. The entropy $H$ with respect to the probability $p$ over actions is\n",
        "\n",
        "$$ H(P) = - \\sum_a p(a) \\log p(a) $$\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LwLhlnim9Nnc"
      },
      "source": [
        "## import module"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "64TFaTtE9Nnc"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "from typing import 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\n",
        "from torch.distributions import Normal"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0GP4TXOk9Nnd"
      },
      "source": [
        "## Network\n",
        "We will use two separated networks for actor and critic respectively. The actor network consists of one fully connected hidden layer with ReLU branched out two fully connected output layers for mean and standard deviation of Normal distribution. Pendulum-v0 has only one action which has a range from -2 to 2. In order to fit the range, the actor outputs the mean value that is multiplied by 2 after tanh. On the one hand, the critic network has two fully connected layers as a hidden layer (ReLU) and an output layer. One thing to note is that we initialize the last layers' weights and biases as uniformly distributed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "t1MBQFoT9Nne"
      },
      "outputs": [],
      "source": [
        "def initialize_uniformly(layer: nn.Linear, init_w: float = 3e-3):\n",
        "    \"\"\"Initialize the weights and bias in [-init_w, init_w].\"\"\"\n",
        "    layer.weight.data.uniform_(-init_w, init_w)\n",
        "    layer.bias.data.uniform_(-init_w, init_w)\n",
        "\n",
        "\n",
        "class Actor(nn.Module):\n",
        "    def __init__(self, in_dim: int, out_dim: int):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        super(Actor, self).__init__()\n",
        "\n",
        "        self.hidden1 = nn.Linear(in_dim, 128)\n",
        "        self.mu_layer = nn.Linear(128, out_dim)\n",
        "        self.log_std_layer = nn.Linear(128, out_dim)\n",
        "\n",
        "        initialize_uniformly(self.mu_layer)\n",
        "        initialize_uniformly(self.log_std_layer)\n",
        "\n",
        "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Forward method implementation.\"\"\"\n",
        "        x = F.relu(self.hidden1(state))\n",
        "\n",
        "        mu = torch.tanh(self.mu_layer(x)) * 2\n",
        "        log_std = F.softplus(self.log_std_layer(x))\n",
        "        std = torch.exp(log_std)\n",
        "\n",
        "        dist = Normal(mu, std)\n",
        "        action = dist.sample()\n",
        "\n",
        "        return action, dist\n",
        "\n",
        "\n",
        "class Critic(nn.Module):\n",
        "    def __init__(self, in_dim: int):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        super(Critic, self).__init__()\n",
        "\n",
        "        self.hidden1 = nn.Linear(in_dim, 128)\n",
        "        self.out = nn.Linear(128, 1)\n",
        "\n",
        "        initialize_uniformly(self.out)\n",
        "\n",
        "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Forward method implementation.\"\"\"\n",
        "        x = F.relu(self.hidden1(state))\n",
        "        value = self.out(x)\n",
        "\n",
        "        return value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wX1H8ylr9Nne"
      },
      "source": [
        "## A2C Agent\n",
        "Here is a summary of A2CAgent 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",
        "|update_model      | update the model by gradient descent.                |\n",
        "|train             | train the agent during num_frames.                   |\n",
        "|test              | test the agent (1 episode).                          |\n",
        "|plot              | plot the training progresses.                        |"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "mrUtbRh29Nne"
      },
      "outputs": [],
      "source": [
        "class A2CAgent:\n",
        "    \"\"\"A2CAgent interacting with environment.\n",
        "\n",
        "    Atribute:\n",
        "        env (gym.Env): openAI Gym environment\n",
        "        gamma (float): discount factor\n",
        "        entropy_weight (float): rate of weighting entropy into the loss function\n",
        "        device (torch.device): cpu / gpu\n",
        "        actor (nn.Module): target actor model to select actions\n",
        "        critic (nn.Module): critic model to predict state values\n",
        "        actor_optimizer (optim.Optimizer) : optimizer of actor\n",
        "        critic_optimizer (optim.Optimizer) : optimizer of critic\n",
        "        transition (list): temporory storage for the recent transition\n",
        "        total_step (int): total step numbers\n",
        "        is_test (bool): flag to show the current mode (train / test)\n",
        "        seed (int): random seed\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, env: gym.Env, gamma: float, entropy_weight: float, seed: int = 777):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        self.env = env\n",
        "        self.gamma = gamma\n",
        "        self.entropy_weight = entropy_weight\n",
        "        self.seed = seed\n",
        "\n",
        "        # device: cpu / gpu\n",
        "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "        print(self.device)\n",
        "\n",
        "        # networks\n",
        "        obs_dim = env.observation_space.shape[0]\n",
        "        action_dim = env.action_space.shape[0]\n",
        "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
        "        self.critic = Critic(obs_dim).to(self.device)\n",
        "\n",
        "        # optimizer\n",
        "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=1e-4)\n",
        "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
        "\n",
        "        # transition (state, log_prob, next_state, reward, done)\n",
        "        self.transition: list = list()\n",
        "\n",
        "        # total steps count\n",
        "        self.total_step = 0\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",
        "        state = torch.FloatTensor(state).to(self.device)\n",
        "        action, dist = self.actor(state)\n",
        "        selected_action = dist.mean if self.is_test else action\n",
        "\n",
        "        if not self.is_test:\n",
        "            log_prob = dist.log_prob(selected_action).sum(dim=-1)\n",
        "            self.transition = [state, log_prob]\n",
        "\n",
        "        return selected_action.clamp(-2.0, 2.0).cpu().detach().numpy()\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.extend([next_state, reward, done])\n",
        "\n",
        "        return next_state, reward, done\n",
        "\n",
        "    def update_model(self) -> Tuple[torch.Tensor, torch.Tensor]:\n",
        "        \"\"\"Update the model by gradient descent.\"\"\"\n",
        "        state, log_prob, next_state, reward, done = self.transition\n",
        "\n",
        "        # Q_t   = r + gamma * V(s_{t+1})  if state != Terminal\n",
        "        #       = r                       otherwise\n",
        "        mask = 1 - done\n",
        "        next_state = torch.FloatTensor(next_state).to(self.device)\n",
        "        pred_value = self.critic(state)\n",
        "        targ_value = reward + self.gamma * self.critic(next_state) * mask\n",
        "        value_loss = F.smooth_l1_loss(pred_value, targ_value.detach())\n",
        "\n",
        "        # update value\n",
        "        self.critic_optimizer.zero_grad()\n",
        "        value_loss.backward()\n",
        "        self.critic_optimizer.step()\n",
        "\n",
        "        # advantage = Q_t - V(s_t)\n",
        "        advantage = (targ_value - pred_value).detach()  # not backpropagated\n",
        "        policy_loss = -advantage * log_prob\n",
        "        policy_loss += self.entropy_weight * -log_prob  # entropy maximization\n",
        "\n",
        "        # update policy\n",
        "        self.actor_optimizer.zero_grad()\n",
        "        policy_loss.backward()\n",
        "        self.actor_optimizer.step()\n",
        "\n",
        "        return policy_loss.item(), value_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",
        "        actor_losses, critic_losses, scores = [], [], []\n",
        "        state, _ = self.env.reset(seed=self.seed)\n",
        "        score = 0\n",
        "\n",
        "        for self.total_step in range(1, num_frames + 1):\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            actor_loss, critic_loss = self.update_model()\n",
        "            actor_losses.append(actor_loss)\n",
        "            critic_losses.append(critic_loss)\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",
        "            # plot\n",
        "            if self.total_step % plotting_interval == 0:\n",
        "                self._plot(self.total_step, scores, actor_losses, critic_losses)\n",
        "        self.env.close()\n",
        "\n",
        "    def test(self, video_folder: str):\n",
        "        \"\"\"Test the agent.\"\"\"\n",
        "        self.is_test = True\n",
        "\n",
        "        tmp_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",
        "        self.env = tmp_env\n",
        "\n",
        "    def _plot(\n",
        "        self,\n",
        "        frame_idx: int,\n",
        "        scores: List[float],\n",
        "        actor_losses: List[float],\n",
        "        critic_losses: List[float],\n",
        "    ):\n",
        "        \"\"\"Plot the training progresses.\"\"\"\n",
        "\n",
        "        def subplot(loc: int, title: str, values: List[float]):\n",
        "            plt.subplot(loc)\n",
        "            plt.title(title)\n",
        "            plt.plot(values)\n",
        "\n",
        "        subplot_params = [\n",
        "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
        "            (132, \"actor_loss\", actor_losses),\n",
        "            (133, \"critic_loss\", critic_losses),\n",
        "        ]\n",
        "\n",
        "        clear_output(True)\n",
        "        plt.figure(figsize=(30, 5))\n",
        "        for loc, title, values in subplot_params:\n",
        "            subplot(loc, title, values)\n",
        "        plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dNvD7ppH9Nnf"
      },
      "source": [
        "## Environment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ReNSsWTt9Nnf"
      },
      "source": [
        "You can see [the code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/pendulum.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/e73245912087d47b538dcdb45fa9a9d185b805c5/gymnasium/envs/__init__.py#L41) of Pendulum-v1 from Gymnasyim repository."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "PK9d7SBQ9Nnf"
      },
      "outputs": [],
      "source": [
        "# environment\n",
        "env = gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q59eeKYO-FtG"
      },
      "source": [
        "## Set random seed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "78Lbwafm-Gzv"
      },
      "outputs": [],
      "source": [
        "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",
        "\n",
        "seed = 777\n",
        "random.seed(seed)\n",
        "np.random.seed(seed)\n",
        "seed_torch(seed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UP-KFxGQ9Nnf"
      },
      "source": [
        "## Initialize"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "9PQl2ZfS9Nnf",
        "outputId": "89e26a81-045f-474f-fe92-fa2e8d38caab",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "num_frames = 100000\n",
        "gamma = 0.9\n",
        "entropy_weight = 1e-2\n",
        "\n",
        "agent = A2CAgent(env, gamma, entropy_weight, seed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sr5N63DL9Nng"
      },
      "source": [
        "## Train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "FcSfuw9h9Nng",
        "outputId": "bdb29e59-c46c-4710-9424-fc27de844d4e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 318
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 3000x500 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "agent.train(num_frames)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kz1mY15w9Nng"
      },
      "source": [
        "## Test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "KuGSvYK-9Nng",
        "outputId": "e7781e9b-5036-4147-bef0-dbec3d207ef7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "score:  -134.81868839539598\n"
          ]
        }
      ],
      "source": [
        "# test\n",
        "video_folder = \"videos/a2c\"\n",
        "agent.test(video_folder=video_folder)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IfNxDFpe9Nng"
      },
      "source": [
        "## Render"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "YVyGhnuj9Nng",
        "outputId": "1f776aa0-c606-44c0-ce98-c165b2198f0c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "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",
              "        "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Played: videos/a2c/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(\n",
        "        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(\n",
        "                encoded.decode(\"ascii\")\n",
        "            )\n",
        "        )\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)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IBa8y3Vm9Nnh"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "display_name": "pgayn",
      "language": "python",
      "name": "pgayn"
    },
    "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.6.9"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}