A3C_Kung_Fu_Master.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dIo6Zkp7U1Hq"
      },
      "source": [
        "# A3C for Kung Fu"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pz8ogVxGVB6b"
      },
      "source": [
        "## Part 0 - Installing the required packages and importing the libraries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CqN2IEX1VKzi"
      },
      "source": [
        "### Installing Gymnasium"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dbnq3XpoKa_7",
        "outputId": "ab001b4f-50b0-4006-a148-7c40a8bbca00"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: gymnasium in /usr/local/lib/python3.10/dist-packages (0.29.1)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (1.25.2)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (2.2.1)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (4.11.0)\n",
            "Requirement already satisfied: farama-notifications>=0.0.1 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (0.0.4)\n",
            "Requirement already satisfied: gymnasium[accept-rom-license,atari] in /usr/local/lib/python3.10/dist-packages (0.29.1)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (1.25.2)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (2.2.1)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (4.11.0)\n",
            "Requirement already satisfied: farama-notifications>=0.0.1 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (0.0.4)\n",
            "Requirement already satisfied: autorom[accept-rom-license]~=0.4.2 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (0.4.2)\n",
            "Requirement already satisfied: shimmy[atari]<1.0,>=0.1.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (0.2.1)\n",
            "Requirement already satisfied: click in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (8.1.7)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (4.66.4)\n",
            "Requirement already satisfied: AutoROM.accept-rom-license in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (0.6.1)\n",
            "Requirement already satisfied: ale-py~=0.8.1 in /usr/local/lib/python3.10/dist-packages (from shimmy[atari]<1.0,>=0.1.0->gymnasium[accept-rom-license,atari]) (0.8.1)\n",
            "Requirement already satisfied: importlib-resources in /usr/local/lib/python3.10/dist-packages (from ale-py~=0.8.1->shimmy[atari]<1.0,>=0.1.0->gymnasium[accept-rom-license,atari]) (6.4.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (2024.2.2)\n",
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "swig is already the newest version (4.0.2-1ubuntu1).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 45 not upgraded.\n",
            "Requirement already satisfied: gymnasium[box2d] in /usr/local/lib/python3.10/dist-packages (0.29.1)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (1.25.2)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (2.2.1)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (4.11.0)\n",
            "Requirement already satisfied: farama-notifications>=0.0.1 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (0.0.4)\n",
            "Requirement already satisfied: box2d-py==2.3.5 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (2.3.5)\n",
            "Requirement already satisfied: pygame>=2.1.3 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (2.5.2)\n",
            "Requirement already satisfied: swig==4.* in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (4.2.1)\n"
          ]
        }
      ],
      "source": [
        "!pip install gymnasium\n",
        "!pip install \"gymnasium[atari, accept-rom-license]\"\n",
        "!apt-get install -y swig\n",
        "!pip install gymnasium[box2d]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BrsNHNQqVZLK"
      },
      "source": [
        "### Importing the libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ho_25-9_9qnu"
      },
      "outputs": [],
      "source": [
        "import cv2\n",
        "import math\n",
        "import random\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "import torch.multiprocessing as mp\n",
        "import torch.distributions as distributions\n",
        "from torch.distributions import Categorical\n",
        "import gymnasium as gym\n",
        "from gymnasium import ObservationWrapper\n",
        "from gymnasium.spaces import Box"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VF6EFSGUVlk2"
      },
      "source": [
        "## Part 1 - Building the AI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qyNc8cxbZCYP"
      },
      "source": [
        "### Creating the architecture of the Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eYFXu6EAT4Kw"
      },
      "outputs": [],
      "source": [
        "class Network(nn.Module):\n",
        "\n",
        "  def __init__(self, action_size):\n",
        "    super(Network, self).__init__()\n",
        "    self.conv1 = torch.nn.Conv2d(in_channels = 4,  out_channels = 32, kernel_size = (3,3), stride = 2)\n",
        "    self.conv2 = torch.nn.Conv2d(in_channels = 32, out_channels = 32, kernel_size = (3,3), stride = 2)\n",
        "    self.conv3 = torch.nn.Conv2d(in_channels = 32, out_channels = 32, kernel_size = (3,3), stride = 2)\n",
        "    self.flatten = torch.nn.Flatten()\n",
        "    self.fc1  = torch.nn.Linear(512, 128)\n",
        "    self.fc2a = torch.nn.Linear(128, action_size)\n",
        "    self.fc2s = torch.nn.Linear(128, 1)\n",
        "\n",
        "  def forward(self, state):\n",
        "    x = self.conv1(state)\n",
        "    x = F.relu(x)\n",
        "    x = self.conv2(x)\n",
        "    x = F.relu(x)\n",
        "    x = self.conv3(x)\n",
        "    x = F.relu(x)\n",
        "    x = self.flatten(x)\n",
        "    x = self.fc1(x)\n",
        "    x = F.relu(x)\n",
        "    action_values = self.fc2a(x)\n",
        "    state_value = self.fc2s(x)[0]\n",
        "    return action_values, state_value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eF5bETqbZbCG"
      },
      "source": [
        "## Part 2 - Training the AI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3C2ydyKLZgaK"
      },
      "source": [
        "### Setting up the environment"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gF756uIhRVcK",
        "outputId": "bea416a8-df95-44c7-95b8-5a8f22b1f296"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "State shape: (4, 42, 42)\n",
            "Number actions: 14\n",
            "Action names: ['NOOP', 'UP', 'RIGHT', 'LEFT', 'DOWN', 'DOWNRIGHT', 'DOWNLEFT', 'RIGHTFIRE', 'LEFTFIRE', 'DOWNFIRE', 'UPRIGHTFIRE', 'UPLEFTFIRE', 'DOWNRIGHTFIRE', 'DOWNLEFTFIRE']\n"
          ]
        }
      ],
      "source": [
        "class PreprocessAtari(ObservationWrapper):\n",
        "\n",
        "  def __init__(self, env, height = 42, width = 42, crop = lambda img: img, dim_order = 'pytorch', color = False, n_frames = 4):\n",
        "    super(PreprocessAtari, self).__init__(env)\n",
        "    self.img_size = (height, width)\n",
        "    self.crop = crop\n",
        "    self.dim_order = dim_order\n",
        "    self.color = color\n",
        "    self.frame_stack = n_frames\n",
        "    n_channels = 3 * n_frames if color else n_frames\n",
        "    obs_shape = {'tensorflow': (height, width, n_channels), 'pytorch': (n_channels, height, width)}[dim_order]\n",
        "    self.observation_space = Box(0.0, 1.0, obs_shape)\n",
        "    self.frames = np.zeros(obs_shape, dtype = np.float32)\n",
        "\n",
        "  def reset(self):\n",
        "    self.frames = np.zeros_like(self.frames)\n",
        "    obs, info = self.env.reset()\n",
        "    self.update_buffer(obs)\n",
        "    return self.frames, info\n",
        "\n",
        "  def observation(self, img):\n",
        "    img = self.crop(img)\n",
        "    img = cv2.resize(img, self.img_size)\n",
        "    if not self.color:\n",
        "      if len(img.shape) == 3 and img.shape[2] == 3:\n",
        "        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "    img = img.astype('float32') / 255.\n",
        "    if self.color:\n",
        "      self.frames = np.roll(self.frames, shift = -3, axis = 0)\n",
        "    else:\n",
        "      self.frames = np.roll(self.frames, shift = -1, axis = 0)\n",
        "    if self.color:\n",
        "      self.frames[-3:] = img\n",
        "    else:\n",
        "      self.frames[-1] = img\n",
        "    return self.frames\n",
        "\n",
        "  def update_buffer(self, obs):\n",
        "    self.frames = self.observation(obs)\n",
        "\n",
        "def make_env():\n",
        "  env = gym.make(\"KungFuMasterDeterministic-v0\", render_mode = 'rgb_array')\n",
        "  env = PreprocessAtari(env, height = 42, width = 42, crop = lambda img: img, dim_order = 'pytorch', color = False, n_frames = 4)\n",
        "  return env\n",
        "\n",
        "env = make_env()\n",
        "\n",
        "state_shape = env.observation_space.shape\n",
        "number_actions = env.action_space.n\n",
        "print(\"State shape:\", state_shape)\n",
        "print(\"Number actions:\", number_actions)\n",
        "print(\"Action names:\", env.env.env.get_action_meanings())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YgRlooBmC1hr"
      },
      "source": [
        "### Initializing the hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iio4XgZhC2XN"
      },
      "outputs": [],
      "source": [
        "learning_rate = 1e-4\n",
        "discount_factor = 0.99\n",
        "number_environments = 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gg_LmSs9IoTX"
      },
      "source": [
        "### Implementing the A3C class"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uNvmCJIDIwVZ"
      },
      "outputs": [],
      "source": [
        "class Agent():\n",
        "\n",
        "  def __init__(self, action_size):\n",
        "    self.device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    self.action_size = action_size\n",
        "    self.network = Network(action_size).to(self.device)\n",
        "    self.optimizer = torch.optim.Adam(self.network.parameters(), lr = learning_rate)\n",
        "\n",
        "  def act(self, state):\n",
        "    if state.ndim == 3:\n",
        "      state = [state]\n",
        "    state = torch.tensor(state, dtype = torch.float32, device = self.device)\n",
        "    action_values, _ = self.network(state)\n",
        "    policy = F.softmax(action_values, dim = -1)\n",
        "    return np.array([np.random.choice(len(p), p = p) for p in policy.detach().cpu().numpy()])\n",
        "\n",
        "  def step(self, state, action, reward, next_state, done):\n",
        "    batch_size = state.shape[0]\n",
        "    state = torch.tensor(state, dtype = torch.float32, device = self.device)\n",
        "    next_state = torch.tensor(next_state, dtype = torch.float32, device = self.device)\n",
        "    reward = torch.tensor(reward, dtype = torch.float32, device = self.device)\n",
        "    done = torch.tensor(done, dtype = torch.bool, device = self.device).to(dtype = torch.float32)\n",
        "    action_values, state_value = self.network(state)\n",
        "    _, next_state_value = self.network(next_state)\n",
        "    target_state_value = reward + discount_factor * next_state_value * (1 - done)\n",
        "    advantage = target_state_value - state_value\n",
        "    probs = F.softmax(action_values, dim = -1)\n",
        "    logprobs = F.log_softmax(action_values, dim = -1)\n",
        "    entropy = -torch.sum(probs * logprobs, axis = -1)\n",
        "    batch_idx = np.arange(batch_size)\n",
        "    logp_actions = logprobs[batch_idx, action]\n",
        "    actor_loss = -(logp_actions * advantage.detach()).mean() - 0.001 * entropy.mean()\n",
        "    critic_loss = F.mse_loss(target_state_value.detach(), state_value)\n",
        "    total_loss = actor_loss + critic_loss\n",
        "    self.optimizer.zero_grad()\n",
        "    total_loss.backward()\n",
        "    self.optimizer.step()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7RnRukHDKFJ0"
      },
      "source": [
        "### Initializing the A3C agent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_V6RUlHdKFSz"
      },
      "outputs": [],
      "source": [
        "agent = Agent(number_actions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oB5SpmoKP0aK"
      },
      "source": [
        "### Evaluating our A3C agent on a certain number of episodes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RU1v_9UbUQv7"
      },
      "outputs": [],
      "source": [
        "import imageio\n",
        "import calendar\n",
        "import time\n",
        "\n",
        "def evaluate(agent, env, n_episodes = 1):\n",
        "  episodes_rewards = []\n",
        "  for _ in range(n_episodes):\n",
        "    state, _ = env.reset()\n",
        "    total_reward = 0\n",
        "    frames = []\n",
        "    while True:\n",
        "      frame = env.render()\n",
        "      frames.append(frame)\n",
        "      action = agent.act(state)\n",
        "      state, reward, done, info, _ = env.step(action[0])\n",
        "      total_reward += reward\n",
        "      if done:\n",
        "        env.close()\n",
        "        kargs = { 'fps': 30, 'quality': 10, 'macro_block_size': None, 'ffmpeg_params': ['-s','600x450'] }\n",
        "        gmt = time.gmtime()\n",
        "        ts = calendar.timegm(gmt)\n",
        "        imageio.mimsave('training/train-'+str(ts)+'.mp4', frames, **kargs)\n",
        "        break\n",
        "    episodes_rewards.append(total_reward)\n",
        "  return episodes_rewards\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jVSqiyjiQeMd"
      },
      "source": [
        "### Managing multiple environments simultaneously"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1GPEjnFyU_GD"
      },
      "outputs": [],
      "source": [
        "class EnvBatch:\n",
        "\n",
        "  def __init__(self, n_envs = 10):\n",
        "    self.envs = [make_env() for _ in range(n_envs)]\n",
        "\n",
        "  def reset(self):\n",
        "    _states = []\n",
        "    for env in self.envs:\n",
        "      _states.append(env.reset()[0])\n",
        "    return np.array(_states)\n",
        "\n",
        "  def step(self, actions):\n",
        "    next_states, rewards, dones, infos, _ = map(np.array, zip(*[env.step(a) for env, a in zip(self.envs, actions)]))\n",
        "    for i in range(len(self.envs)):\n",
        "      if dones[i]:\n",
        "        next_states[i] = self.envs[i].reset()[0]\n",
        "    return next_states, rewards, dones, infos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "69WZWB4oRx1P"
      },
      "source": [
        "### Training the A3C agent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HFkkVttVxSM8",
        "outputId": "600bba6a-8453-4e20-dd87-b84b9aff7f05"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/3001 [00:00<?, ?it/s]<ipython-input-26-0725e4aa1061>:33: UserWarning: Using a target size (torch.Size([1])) that is different to the input size (torch.Size([10])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
            "  critic_loss = F.mse_loss(target_state_value.detach(), state_value)\n",
            "  0%|          | 6/3001 [01:32<9:24:26, 11.31s/it] "
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Average agent reward:  390.0\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            " 33%|███▎      | 1005/3001 [03:29<3:32:27,  6.39s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Average agent reward:  420.0\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            " 67%|██████▋   | 2005/3001 [05:46<1:31:24,  5.51s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Average agent reward:  1190.0\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 3001/3001 [07:57<00:00,  6.28it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Average agent reward:  990.0\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "import tqdm\n",
        "\n",
        "env_batch = EnvBatch(number_environments)\n",
        "batch_states = env_batch.reset()\n",
        "\n",
        "with tqdm.trange(0, 3001) as progress_bar:\n",
        "  for i in progress_bar:\n",
        "    batch_actions = agent.act(batch_states)\n",
        "    batch_next_states, batch_rewards, batch_dones, _ = env_batch.step(batch_actions)\n",
        "    batch_rewards *= 0.01\n",
        "    agent.step(batch_states, batch_actions, batch_rewards, batch_next_states, batch_dones)\n",
        "    batch_states = batch_next_states\n",
        "    if i % 1000 == 0:\n",
        "      print(\"Average agent reward: \", np.mean(evaluate(agent, env, n_episodes = 10)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_tYh43InqMLo"
      },
      "outputs": [],
      "source": [
        "# Compress all training video\n",
        "import os\n",
        "import zipfile\n",
        "\n",
        "def zipdir(path, ziph):\n",
        "    # ziph is zipfile handle\n",
        "    for root, dirs, files in os.walk(path):\n",
        "        for file in files:\n",
        "            ziph.write(os.path.join(root, file),\n",
        "                       os.path.relpath(os.path.join(root, file),\n",
        "                                       os.path.join(path, '..')))\n",
        "\n",
        "with zipfile.ZipFile('training.zip', 'w', zipfile.ZIP_DEFLATED) as zipf:\n",
        "    zipdir('training/', zipf)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vbg060y3qX8a",
        "outputId": "68f12f84-e026-4a90-a203-b764ad966286"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:py.warnings:/usr/local/lib/python3.10/dist-packages/skimage/util/dtype.py:27: DeprecationWarning: `np.bool8` is a deprecated alias for `np.bool_`.  (Deprecated NumPy 1.24)\n",
            "  np.bool8: (False, True),\n",
            "\n",
            "WARNING:py.warnings:/usr/local/lib/python3.10/dist-packages/moviepy/video/fx/painting.py:7: DeprecationWarning: Please use `sobel` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n",
            "  from scipy.ndimage.filters import sobel\n",
            "\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Moviepy - Building video training.mp4.\n",
            "Moviepy - Writing video training.mp4\n",
            "\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": []
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Moviepy - Done !\n",
            "Moviepy - video ready training.mp4\n"
          ]
        }
      ],
      "source": [
        "# Merge All training video\n",
        "from moviepy.editor import *\n",
        "import os\n",
        "from natsort import natsorted\n",
        "\n",
        "L = []\n",
        "\n",
        "for root, dirs, files in os.walk(\"training/\"):\n",
        "\n",
        "    #files.sort()\n",
        "    files = natsorted(files)\n",
        "    for file in files:\n",
        "        if os.path.splitext(file)[1] == '.mp4':\n",
        "            filePath = os.path.join(root, file)\n",
        "            video = VideoFileClip(filePath)\n",
        "            L.append(video)\n",
        "\n",
        "final_clip = concatenate_videoclips(L)\n",
        "final_clip.to_videofile(\"training.mp4\", fps=24, remove_temp=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7kG_YR9YdmUM"
      },
      "source": [
        "## Part 3 - Visualizing the results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 459
        },
        "id": "UGkTuO6DxZ6B",
        "outputId": "3de33d83-a831-4b62-929f-ef4bd28b3dbc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:imageio_ffmpeg:IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (160, 210) to (160, 224) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<video alt=\"test\" autoplay\n",
              "                loop controls style=\"height: 400px;\">\n",
              "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
              "             </video>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "import glob\n",
        "import io\n",
        "import base64\n",
        "import imageio\n",
        "from IPython.display import HTML, display\n",
        "from gymnasium.wrappers.monitoring.video_recorder import VideoRecorder\n",
        "\n",
        "def show_video_of_model(agent, env):\n",
        "  state, _ = env.reset()\n",
        "  done = False\n",
        "  frames = []\n",
        "  while not done:\n",
        "    frame = env.render()\n",
        "    frames.append(frame)\n",
        "    action = agent.act(state)\n",
        "    state, reward, done, _, _ = env.step(action[0])\n",
        "  env.close()\n",
        "  imageio.mimsave('video.mp4', frames, fps=30)\n",
        "\n",
        "show_video_of_model(agent, env)\n",
        "\n",
        "def show_video():\n",
        "    mp4list = glob.glob('video.mp4')\n",
        "    if len(mp4list) > 0:\n",
        "        mp4 = mp4list[0]\n",
        "        video = io.open(mp4, 'r+b').read()\n",
        "        encoded = base64.b64encode(video)\n",
        "        display(HTML(data='''<video alt=\"test\" autoplay\n",
        "                loop controls style=\"height: 400px;\">\n",
        "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
        "             </video>'''.format(encoded.decode('ascii'))))\n",
        "    else:\n",
        "        print(\"Could not find video\")\n",
        "\n",
        "show_video()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}