RL_PPO_Cartpole.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w-jFCArcTC-B"
   },
   "source": [
    "<a \n",
    "href=\"https://colab.research.google.com/github/wingated/cs474_labs_f2019/blob/master/DL_Lab9.ipynb\"\n",
    "  target=\"_parent\">\n",
    "  <img\n",
    "    src=\"https://colab.research.google.com/assets/colab-badge.svg\"\n",
    "    alt=\"Open In Colab\"/>\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sl7hEuB3J4k3"
   },
   "source": [
    "# Deep Reinforcement Learning\n",
    "\n",
    "## Objective\n",
    "\n",
    "- Build DQN and PPO Deep RL algorithms\n",
    "- Explain the difference between Q Learning and Policy Gradient techniques\n",
    "\n",
    "\n",
    "### Cartpole\n",
    "\n",
    "Cartpole is a simple environment to get your agent up and running. It has a continuous state space of 4 dimensions and a discrete action space of 2. The agent is given a reward of 1 for each timestep it remains standing. Your agent should be able to reach close to 200 cumulative reward for an episode after a minute or two of training. The below graphs show example results for dqn (left) and ppo (right).\n",
    "\n",
    "![alt text](https://drive.google.com/uc?export=view&id=1Bpz1jOPMF1zJMW6XBJJ44sJ-RmO_q6_U)\n",
    "![alt text](https://drive.google.com/uc?export=view&id=1M1yygXhLKDL8qfRXn7fh_K-zq7-pQRhY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WhaPOG6xt0yn"
   },
   "source": [
    "## Init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EyykNyRM1Tf3",
    "outputId": "dd78d150-e42b-4356-d0d5-032417c12f55"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
      "Collecting gymnasium\n",
      "  Downloading gymnasium-0.28.1-py3-none-any.whl (925 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m925.5/925.5 KB\u001b[0m \u001b[31m45.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hCollecting farama-notifications>=0.0.1\n",
      "  Downloading Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n",
      "Collecting jax-jumpy>=1.0.0\n",
      "  Downloading jax_jumpy-1.0.0-py3-none-any.whl (20 kB)\n",
      "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.9/dist-packages (from gymnasium) (1.22.4)\n",
      "Requirement already satisfied: importlib-metadata>=4.8.0 in /usr/local/lib/python3.9/dist-packages (from gymnasium) (6.1.0)\n",
      "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.9/dist-packages (from gymnasium) (2.2.1)\n",
      "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.9/dist-packages (from gymnasium) (4.5.0)\n",
      "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata>=4.8.0->gymnasium) (3.15.0)\n",
      "Installing collected packages: farama-notifications, jax-jumpy, gymnasium\n",
      "Successfully installed farama-notifications-0.0.4 gymnasium-0.28.1 jax-jumpy-1.0.0\n",
      "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
      "Requirement already satisfied: torch in /usr/local/lib/python3.9/dist-packages (1.13.1+cu116)\n",
      "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.9/dist-packages (from torch) (4.5.0)\n",
      "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
      "Requirement already satisfied: pygame in /usr/local/lib/python3.9/dist-packages (2.3.0)\n",
      "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
      "Requirement already satisfied: moviepy==1.0.3 in /usr/local/lib/python3.9/dist-packages (1.0.3)\n",
      "Requirement already satisfied: imageio<3.0,>=2.5 in /usr/local/lib/python3.9/dist-packages (from moviepy==1.0.3) (2.25.1)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from moviepy==1.0.3) (1.22.4)\n",
      "Requirement already satisfied: proglog<=1.0.0 in /usr/local/lib/python3.9/dist-packages (from moviepy==1.0.3) (0.1.10)\n",
      "Requirement already satisfied: decorator<5.0,>=4.0.2 in /usr/local/lib/python3.9/dist-packages (from moviepy==1.0.3) (4.4.2)\n",
      "Requirement already satisfied: tqdm<5.0,>=4.11.2 in /usr/local/lib/python3.9/dist-packages (from moviepy==1.0.3) (4.65.0)\n",
      "Requirement already satisfied: imageio-ffmpeg>=0.2.0 in /usr/local/lib/python3.9/dist-packages (from moviepy==1.0.3) (0.4.8)\n",
      "Requirement already satisfied: requests<3.0,>=2.8.1 in /usr/local/lib/python3.9/dist-packages (from moviepy==1.0.3) (2.27.1)\n",
      "Requirement already satisfied: pillow>=8.3.2 in /usr/local/lib/python3.9/dist-packages (from imageio<3.0,>=2.5->moviepy==1.0.3) (8.4.0)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests<3.0,>=2.8.1->moviepy==1.0.3) (1.26.15)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests<3.0,>=2.8.1->moviepy==1.0.3) (2022.12.7)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests<3.0,>=2.8.1->moviepy==1.0.3) (3.4)\n",
      "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests<3.0,>=2.8.1->moviepy==1.0.3) (2.0.12)\n",
      "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
      "Requirement already satisfied: imageio_ffmpeg in /usr/local/lib/python3.9/dist-packages (0.4.8)\n",
      "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
      "Collecting pyvirtualdisplay\n",
      "  Downloading PyVirtualDisplay-3.0-py3-none-any.whl (15 kB)\n",
      "Installing collected packages: pyvirtualdisplay\n",
      "Successfully installed pyvirtualdisplay-3.0\n",
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "ffmpeg is already the newest version (7:4.2.7-0ubuntu0.1).\n",
      "The following additional packages will be installed:\n",
      "  freeglut3 libpython2-stdlib python2 python2-minimal\n",
      "Suggested packages:\n",
      "  python-tk python-numpy libgle3 python2-doc\n",
      "The following NEW packages will be installed:\n",
      "  freeglut3 libpython2-stdlib python-opengl python2 python2-minimal xvfb\n",
      "0 upgraded, 6 newly installed, 0 to remove and 23 not upgraded.\n",
      "Need to get 1,400 kB of archives.\n",
      "After this operation, 8,330 kB of additional disk space will be used.\n",
      "Get:1 http://archive.ubuntu.com/ubuntu focal/universe amd64 python2-minimal amd64 2.7.17-2ubuntu4 [27.5 kB]\n",
      "Get:2 http://archive.ubuntu.com/ubuntu focal/universe amd64 libpython2-stdlib amd64 2.7.17-2ubuntu4 [7,072 B]\n",
      "Get:3 http://archive.ubuntu.com/ubuntu focal/universe amd64 python2 amd64 2.7.17-2ubuntu4 [26.5 kB]\n",
      "Get:4 http://archive.ubuntu.com/ubuntu focal/universe amd64 freeglut3 amd64 2.8.1-3 [73.6 kB]\n",
      "Get:5 http://archive.ubuntu.com/ubuntu focal/universe amd64 python-opengl all 3.1.0+dfsg-2build1 [486 kB]\n",
      "Get:6 http://archive.ubuntu.com/ubuntu focal-updates/universe amd64 xvfb amd64 2:1.20.13-1ubuntu1~20.04.6 [780 kB]\n",
      "Fetched 1,400 kB in 2s (794 kB/s)\n",
      "Selecting previously unselected package python2-minimal.\n",
      "(Reading database ... 128288 files and directories currently installed.)\n",
      "Preparing to unpack .../python2-minimal_2.7.17-2ubuntu4_amd64.deb ...\n",
      "Unpacking python2-minimal (2.7.17-2ubuntu4) ...\n",
      "Selecting previously unselected package libpython2-stdlib:amd64.\n",
      "Preparing to unpack .../libpython2-stdlib_2.7.17-2ubuntu4_amd64.deb ...\n",
      "Unpacking libpython2-stdlib:amd64 (2.7.17-2ubuntu4) ...\n",
      "Setting up python2-minimal (2.7.17-2ubuntu4) ...\n",
      "Selecting previously unselected package python2.\n",
      "(Reading database ... 128317 files and directories currently installed.)\n",
      "Preparing to unpack .../python2_2.7.17-2ubuntu4_amd64.deb ...\n",
      "Unpacking python2 (2.7.17-2ubuntu4) ...\n",
      "Selecting previously unselected package freeglut3:amd64.\n",
      "Preparing to unpack .../freeglut3_2.8.1-3_amd64.deb ...\n",
      "Unpacking freeglut3:amd64 (2.8.1-3) ...\n",
      "Selecting previously unselected package python-opengl.\n",
      "Preparing to unpack .../python-opengl_3.1.0+dfsg-2build1_all.deb ...\n",
      "Unpacking python-opengl (3.1.0+dfsg-2build1) ...\n",
      "Selecting previously unselected package xvfb.\n",
      "Preparing to unpack .../xvfb_2%3a1.20.13-1ubuntu1~20.04.6_amd64.deb ...\n",
      "Unpacking xvfb (2:1.20.13-1ubuntu1~20.04.6) ...\n",
      "Setting up freeglut3:amd64 (2.8.1-3) ...\n",
      "Setting up libpython2-stdlib:amd64 (2.7.17-2ubuntu4) ...\n",
      "Setting up xvfb (2:1.20.13-1ubuntu1~20.04.6) ...\n",
      "Setting up python2 (2.7.17-2ubuntu4) ...\n",
      "Setting up python-opengl (3.1.0+dfsg-2build1) ...\n",
      "Processing triggers for man-db (2.9.1-1) ...\n",
      "Processing triggers for libc-bin (2.31-0ubuntu9.9) ...\n"
     ]
    }
   ],
   "source": [
    "! pip3 install gymnasium\n",
    "! pip3 install torch\n",
    "! pip install pygame\n",
    "! pip install moviepy==1.0.3\n",
    "! pip install imageio_ffmpeg\n",
    "####################\n",
    "! pip install pyvirtualdisplay\n",
    "! apt-get install -y xvfb python-opengl ffmpeg\n",
    "####################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "Rim8iocC1Vva"
   },
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from itertools import chain\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import numpy as np\n",
    "\n",
    "####################\n",
    "from gymnasium import logger as gymlogger\n",
    "from gymnasium.wrappers import RecordVideo\n",
    "gymlogger.set_level(40) #error only\n",
    "\n",
    "import glob\n",
    "import io\n",
    "import base64\n",
    "from IPython.display import HTML\n",
    "from IPython import display as ipythondisplay\n",
    "####################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "l1f8lZp19Lwj",
    "outputId": "c62c630d-c618-4989-b6ae-7dcfce80657e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pyvirtualdisplay.display.Display at 0x7f5f5417a760>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "######################\n",
    "from pyvirtualdisplay import Display\n",
    "display = Display(visible=0, size=(1400,900))\n",
    "display.start()\n",
    "######################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "_TI_5c0l9Ojv"
   },
   "outputs": [],
   "source": [
    "######################\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",
    "    ipythondisplay.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",
    "def wrap_env(env):\n",
    "  env = RecordVideo(env, './video')\n",
    "  return env\n",
    "######################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mV282uYJ2aSw"
   },
   "source": [
    "## DQN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Qi_aDdTg2btp"
   },
   "source": [
    "## Part 1\n",
    "\n",
    "\n",
    "Deep Q-Network (https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf) is a Q-learning algorithm that learns values for state-action pairs.\n",
    "\n",
    "Actions are sampled according to an $\\epsilon-greedy$ policy to help with exploration of the state space. Every time an action is sampled, the agent chooses a random action with $\\epsilon$ probability. Otherwise, the agent selects the action with the highest Q-value for a state. $\\epsilon$ decays over time according to $\\epsilon \\gets \\epsilon * epsilon\\_decay$.\n",
    "\n",
    "Tuples of state, action, reward, next_state, and terminal $(s,a,r,s',d)$ are collected during training. Every $learn\\_frequency$ steps $sample\\_size$ tuples are sampled and made into 5 tensors tensors of states, actions, rewarads, next_states, and terminals.\n",
    "\n",
    "The loss for a batch of size N is given below.\n",
    "\n",
    "$Loss=\\frac{1}{N}\\sum \\bigg(Q(s,a) - (r + \\gamma \\underset{a'\\sim A}{max} \\hat{Q}(s',a')(1-d))\\bigg)^2 $\n",
    "\n",
    "Loss is calculated and used to update the Q-Network. The target network $\\hat{Q}$ begins as a copy of the Q network but is not updated by the optimizer. Every $target\\_update$ steps, the target network is updated with the parameters of the Q-Network. This process is a type of bootstrapping."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "_mBUvXkT2dHy"
   },
   "outputs": [],
   "source": [
    "def get_action_dqn(network, state, epsilon, epsilon_decay):\n",
    "  \"\"\"Select action according to e-greedy policy and decay epsilon\n",
    "\n",
    "    Args:\n",
    "        network (QNetwork): Q-Network\n",
    "        state (np-array): current state, size (state_size)\n",
    "        epsilon (float): probability of choosing a random action\n",
    "        epsilon_decay (float): amount by which to decay epsilon\n",
    "\n",
    "    Returns:\n",
    "        action (int): chosen action [0, action_size)\n",
    "        epsilon (float): decayed epsilon\n",
    "  \"\"\"\n",
    "  # Get Q-values for the state from the Q-Network\n",
    "  q_values = network(torch.tensor(state).cuda())\n",
    "\n",
    "  # Select action according to e-greedy policy\n",
    "  if np.random.random() < epsilon:\n",
    "      # Choose a random action\n",
    "      action = np.random.randint(0, 2)\n",
    "  else:\n",
    "      # Choose the action with the highest Q-value\n",
    "      action = torch.argmax(q_values).item()\n",
    "\n",
    "  # Decay epsilon\n",
    "  return action, epsilon * epsilon_decay\n",
    "\n",
    "\n",
    "def prepare_batch(memory, batch_size):\n",
    "  \"\"\"Randomly sample batch from memory\n",
    "     Prepare cuda tensors\n",
    "\n",
    "    Args:\n",
    "        memory (list): state, action, next_state, reward, done tuples\n",
    "        batch_size (int): amount of memory to sample into a batch\n",
    "\n",
    "    Returns:\n",
    "        state (tensor): float cuda tensor of size (batch_size x state_size)\n",
    "        action (tensor): long tensor of size (batch_size)\n",
    "        next_state (tensor): float cuda tensor of size (batch_size x state_size)\n",
    "        reward (tensor): float cuda tensor of size (batch_size)\n",
    "        done (tensor): float cuda tensor of size (batch_size)\n",
    "  \"\"\"\n",
    "  # Randomly sample a batch of memory\n",
    "  batch = random.sample(memory, batch_size)\n",
    "\n",
    "  # Convert the batch to tensors and move them to the GPU\n",
    "  state = torch.tensor([transition[0] for transition in batch], dtype=torch.float32).cuda()\n",
    "  action = torch.tensor([transition[1] for transition in batch], dtype=torch.long).cuda()\n",
    "  next_state = torch.tensor([transition[2] for transition in batch], dtype=torch.float32).cuda()\n",
    "  reward = torch.tensor([transition[3] for transition in batch], dtype=torch.float32).cuda()\n",
    "  done = torch.tensor([transition[4] for transition in batch], dtype=torch.float32).cuda()\n",
    "\n",
    "  return state, action, next_state, reward, done\n",
    "\n",
    "  \n",
    "def learn_dqn(batch, optim, q_network, target_network, gamma, global_step, target_update):\n",
    "  \"\"\"Update Q-Network according to DQN Loss function\n",
    "     Update Target Network every target_update global steps\n",
    "\n",
    "    Args:\n",
    "        batch (tuple): tuple of state, action, next_state, reward, and done tensors\n",
    "        optim (Adam): Q-Network optimizer\n",
    "        q_network (QNetwork): Q-Network\n",
    "        target_network (QNetwork): Target Q-Network\n",
    "        gamma (float): discount factor\n",
    "        global_step (int): total steps taken in environment\n",
    "        target_update (int): frequency of target network update\n",
    "  \"\"\"\n",
    "  # Unpack the batch\n",
    "  state, action, next_state, reward, done = batch\n",
    "  action_onehot = F.one_hot(action, 2).bool()\n",
    "\n",
    "  optim.zero_grad()\n",
    "\n",
    "  # Compute Q-values for current state-action pairs using Q-Network\n",
    "  q_values = q_network(state)\n",
    "\n",
    "  # Compute target Q-values using Target Q-Network\n",
    "  # with torch.no_grad():\n",
    "  max_q_next = torch.max(target_network(next_state), dim=1)[0]\n",
    "  target_q_values = reward + gamma * max_q_next * (1 - done)\n",
    "\n",
    "  # Compute DQN loss\n",
    "  loss = F.mse_loss(q_values[action_onehot], target_q_values)\n",
    "\n",
    "  # Backpropagation and optimization\n",
    "  \n",
    "  loss.backward()\n",
    "  optim.step()\n",
    "\n",
    "  # Update target network every target_update global steps\n",
    "  if global_step % target_update == 0:\n",
    "      target_network.load_state_dict(q_network.state_dict())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vGQgiY0WvImB"
   },
   "source": [
    "### Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "1vMhl-oevIBo"
   },
   "outputs": [],
   "source": [
    "# Q-Value Network\n",
    "class QNetwork(nn.Module):\n",
    "  def __init__(self, state_size, action_size):\n",
    "    super().__init__()\n",
    "    hidden_size = 8\n",
    "    \n",
    "    self.net = nn.Sequential(nn.Linear(state_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, action_size))  \n",
    "    \n",
    "  def forward(self, x):\n",
    "    \"\"\"Estimate q-values given state\n",
    "\n",
    "      Args:\n",
    "          state (tensor): current state, size (batch x state_size)\n",
    "\n",
    "      Returns:\n",
    "          q-values (tensor): estimated q-values, size (batch x action_size)\n",
    "    \"\"\"\n",
    "    return self.net(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yCafVI552dgg"
   },
   "source": [
    "### Main"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 612
    },
    "id": "8Sy_r9Wr2eg8",
    "outputId": "f43f0d5a-d408-435a-dc20-d2ae76bffafb"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Episodes: 498 Reward: 185.0: 100%|█████████▉| 499/500 [01:27<00:00,  2.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/183 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  26%|██▌       | 48/183 [00:00<00:00, 432.91it/s, now=None]\u001b[A\n",
      "t:  50%|█████     | 92/183 [00:00<00:00, 373.12it/s, now=None]\u001b[A\n",
      "t:  71%|███████   | 130/183 [00:00<00:00, 333.84it/s, now=None]\u001b[A\n",
      "t:  90%|████████▉ | 164/183 [00:00<00:00, 317.80it/s, now=None]\u001b[A\n",
      "                                                                              "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" autoplay \n",
       "                loop controls style=\"height: 400px;\">\n",
       "                <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAMgRtZGF0AAACrgYF//+q3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1OSByMjk5MSAxNzcxYjU1IC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAxOSAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTMgbG9va2FoZWFkX3RocmVhZHM9MSBzbGljZWRfdGhyZWFkcz0wIG5yPTAgZGVjaW1hdGU9MSBpbnRlcmxhY2VkPTAgYmx1cmF5X2NvbXBhdD0wIGNvbnN0cmFpbmVkX2ludHJhPTAgYmZyYW1lcz0zIGJfcHlyYW1pZD0yIGJfYWRhcHQ9MSBiX2JpYXM9MCBkaXJlY3Q9MSB3ZWlnaHRiPTEgb3Blbl9nb3A9MCB3ZWlnaHRwPTIga2V5aW50PTI1MCBrZXlpbnRfbWluPTI1IHNjZW5lY3V0PTQwIGludHJhX3JlZnJlc2g9MCByY19sb29rYWhlYWQ9NDAgcmM9Y3JmIG1idHJlZT0xIGNyZj0yMy4wIHFjb21wPTAuNjAgcXBtaW49MCBxcG1heD02OSBxcHN0ZXA9NCBpcF9yYXRpbz0xLjQwIGFxPTE6MS4wMACAAAACM2WIhAAz//727L4FNf2f0JcRLMXaSnA+KqSAgHc0wAAAAwAAAwAAFgn0I7DkqgN3QAAAHGAFBCwCPCVC2EhH2Olf8H/BOM9Aov8m/1bp/lybP7+pyFr7Qf5QsgTe7j5m2vOzO5JheBFf6Y7BWDqTnmCGHpIsC+6e4ajIzLYrbo8WvNhsP2ypVgO2Ia4n5Fz70BscCfjWA2suQ3p9elSOtTxPXaVP8wt9fMygXPlY/QCiXVtGgOBUAUMUPXyohX9ZaHIjzESCJgHqhvIy9kpvUongbVzBJZSfjV3Iyl17u67IGL516ZUWhaAJn7m0io9zXFIctMMgZo2q/xhFqRjJwiEAjlTat1VLh46a/c7YnI6JygKKuhIcZbVNjTWiARcqx42N/4uuQJoEWZUWvw3RECrx9b7HCl8oq8pXv0mDnMK6pZXCtHr2T2qS6/A91BRqlHUELUcTpr0ChMsRGKrHTtQ+fPtqjk/fLKfjCR8pSjtpEuZB96vB4CJ+g/LtLQ0VSy/VhbVLvkNT51TjIh8WuyJWDfVsjNEHYlZaxpipawHxXOPTjKQRkw/AeInoEETQc0H0Bcsaf91IanfAChTUINPk78o3zbQ41rwv+eY3ygGawobcYFnn6qL6bWXp955P2nJQK1/0L72PpGAzCAz9DN6W32fMexvagBS07I3HN+9le77JMmBPLRBNPWWYpvjpS1tv74Mk65Fbw4ZbIjGH9AGWj6FCWaPWAAi6I4AAAAMAAIeBAAAAdUGaJGxDP/6eEAAAGnkobYphIa4AEhKxHxHrx30sFpZ3IPTnMtstXJ+CAUzi3PYKW8FJLmmO345aEeLs374bmHOX4o8W3Sa9aWqL1TcrY2GDT6xkBcMr35hL93GZA6NyMLztfX8KqOkd9VvPJXeBGvQbNzLdXAAAAB1BnkJ4hH8AAAgsC46WSVvBCEojtfa3WkTpAH258wAAABwBnmF0R/8AAA017T8cI1vgW3CvIFK7GD155Z3+AAAAEwGeY2pH/wAAAwBBfjWdjXsmmNkAAACAQZpoSahBaJlMCGf//p4QAAAaWQTxr8bfsz5wiXCAAeoVq+K0I8m26Ax6mOesdIZUGoQo95/k2HlQUgQejT7vtVwn2wGUAAZVx45zbVd3tmK5L/Y0t9+TbHQfBpqrtYWNIDIGmtrDcuMPlqRb+rOuAdMzOmu51rhcumMXRti0GIEAAAApQZ6GRREsI/8AAAhtgGTKS24V9WQK//HOtjh7tz2JGJTblNWR32knjSsAAAAcAZ6ldEf/AAADAEFYhKhKRxKO3nn86aEGwvJ8wQAAABsBnqdqR/8AAA2El+QHrBjjZ/vcteCfuOeAYMAAAABOQZqsSahBbJlMCGf//p4QAABFRSXMunT0hkhHf0ThnogCdsxeHGp9N6z1QIY0QjxU57nd2c8wj4D+oiM2x6NbiP4E6etHw0aCuT5XRDN8AAAAIUGeykUVLCP/AAAWvEPNtxXlP1kSI9gbwzobengHYo/tuQAAABEBnul0R/8AAAUc37Mym3AccAAAAB4BnutqR/8AACOxzAlvqW+yFVh5XMSYtI9JlI2ctuAAAAA/QZrwSahBbJlMCGf//p4QAABFUQ4+Gc/R5P3vza6i1KZIyAZA11V8NasfujACiCVdVSGK+Fea74RvcHCr9kLBAAAAIUGfDkUVLCP/AAAWvEPN+MZhA4l5DMlTvy75JDYY7iQTBwAAACIBny10R/8AAA2F3TNrs9QmL2zpjOKqU1+N24OZwfZZanbNAAAAGQGfL2pH/wAAI78EJxLJaZq4VlMjOndR0xYAAABXQZs0SahBbJlMCGf//p4QAABFRSV38GGjLLLsXaVQAj/rO7Kd4+Pwe+Al9Ba9ldYo4oeO3uvCdypJXM95B2AYwCAfEjbXnluRfS27oLM26RpMUS8UmhwcAAAAH0GfUkUVLCP/AAAWvEPNtxXMrJlJPgdCisuHnv/Uck0AAAAOAZ9xdEf/AAADAAADAakAAAAmAZ9zakf/AAAjscwNNoDRTNU+UZC25OAwOM3owCzGdL6QNZh9+DAAAABEQZt4SahBbJlMCF///oywAABGAvaKBX4U1CwAIeAfiDinub5VcRLcigTS5GVQCcWcR9Q1mCR2ydeeqzOeluLl6MiZFcEAAAAoQZ+WRRUsI/8AABa8Q821Gtvi4SFT/M87o/aEvbKl+1dU5aUHGYuVswAAACwBn7V0R/8AAA2Hr6rxLJoz49Uy550G8qpYVw9Rj8IALFnXQL2OvhUHPEgRQQAAABwBn7dqR/8AACOxzAlvqW/roh7oUXTAkXqGanIDAAAAQ0Gbu0moQWyZTAhn//6eEAAARVSXamVG1MnXp1pOrk2Ox7mvtJ0div1WxexlcAAnK/54uVP5qvBNDJNxKXN7zAai2IAAAAAhQZ/ZRRUsI/8AABa8Q823Fcyspq5rRMddYeyyowh0glHJAAAAKgGf+mpH/wAAI7HMDTl1471kGAPXXgAcGmAEsNRmC1Zf471AyB3Bc7P9mAAAAHxBm/9JqEFsmUwIZ//+nhAAAEW6bz7Iq3UEF34WkAJUkaiZrajcAGAbOgduueFdXUxsbbcpAg3MzF59vx5FIB1LcfjzzZRopYT82GrJ0FGacPKAYUZFCsLKNb+cYP2JhSef3FHaTHvFRXGTLb8pdMZFRCWtCntPEK6VhQvJAAAAQEGeHUUVLCP/AAAWtSs3h6hmehQYr/9ZAALZ7rLs4s89fr2sSSf1R7jch7L0WgYaceW2VEu+ZbSYJs+yLEydASsAAAAyAZ48dEf/AAAiwzL8iAEC8WF8+RvGK2zxZv1p0ZuxpaNLNLigyZg4HHn7mmoNZ1ACc2YAAAAsAZ4+akf/AAANCCQjUaKWw/82EN4DuSW25nyO+x7Zra504Xzmgt7b5DZgaKAAAABPQZojSahBbJlMCGf//p4QAABDVJiu+sJPi9QA/k6cod5zLpbe5hPNwcI/yshwy0T9mAtFYUnSkX7tB5Ok0wuMpZ2Gxn6P5jdutjQRzaxq4QAAAC9BnkFFFSwj/wAAFiMsklGCW4XlIEgcjq457Kf/LRRDK/KdE2KTvIOfKwI3KyCGUAAAACMBnmB0R/8AACLAuY2SbQRfmjd0//3ltN48W1RfgVSr0shSQQAAAB4BnmJqR/8AACK/Gs57beVJ4jsd4n/E3Y+8ArEjqfAAAACSQZpnSahBbJlMCGf//p4QAABDRGoiXTlxqwXWB9T22AGuTZU3VZS2SarNIf3rXAvrhlj0FbM/1OOWR0WtzuhWpCz4xs8Ms8dP99SOVgal5AktSVVfRa51dWB1+bfLxZ54mczMnMylDaji/J/mPjIr+v63tQ+WNQSTiOC4EI+1H2AxTDx5pw6SAupFtBEu/6pb9dEAAAAqQZ6FRRUsI/8AABYjLAOljBTJttU8UzPTdhYH7qDjCyVvceESJnypEOitAAAAKQGepHRH/wAAIsM+DnPOBOx3ZJhHPSp+p5z0pUAEAFJ+tW40Z0Te8HBZAAAAKQGepmpH/wAAIr8EJY9rrsm6Um75U9JKZ/za189k/4v5o/4hcVlBJrKhAAAAR0Gaq0moQWyZTAhn//6eEAAAQ0RqIl05S+sxGlf2yjuPq3X1Osy7aBfUvlAC0JiPdkf41MCWGMorO04ygbKdSaxnzcFgWbWAAAAANEGeyUUVLCP/AAAWIyu1BbkcL+XQ/dtVYnnG3IAJqixvY5skfYgbEkkT7k3QRnf+iUsrW6YAAAAfAZ7odEf/AAAiwxdoqaVT1PvCCY6401pY0hZyPSI/8wAAACABnupqR/8AACK/BCcSyWmauFdwgrfLG324rFVbfoFRdwAAAI5Bmu9JqEFsmUwIZ//+nhAAAENDlw8umhEkAE6rDtIw4zZfPfblleElsB4s3PQFROeuuvc9gooojXRifs/xZBo944o9gFvHJbJifLYDnatnh2qwY6rdhGL1ayIIN+V7kmRx0MBTbSxIC6aZiQ78hNBUdqgJTlGgzhznJMrALC28kQjoNET4iIQgYZJ3X6nAAAAAPUGfDUUVLCP/AAAWIp7eNyS8Jt8ICDKhwMbHSkA21BgrbqWjnatQVZBglZbXOxG75a1NWBHZCjqG2IsPG9EAAAAqAZ8sdEf/AAAiq/hdUPYRyCuAAwbFhehOFCQEHO5JWgTRjLIAj80kQdb1AAAAIwGfLmpH/wAAIq4xL9Iy9IDHP1svkLgnjG1uI91f2SO7cT4tAAAASUGbM0moQWyZTAhn//6eEAAAQ0RqIl05cabFGeld78DA3RlQy5BqFQA1mqLVvcObYVcToW+pZYTxFYNMnX/1V4iGPZtGCxLlk4AAAAAqQZ9RRRUsI/8AABYjK7UGLJ4yDHKFKZt988E+GnI5tUAGK+dFMqyTYybAAAAAIgGfcHRH/wAAIsMXYq8fk5HcONZ8JjURP8p32qJMdTcHdvUAAAAoAZ9yakf/AAAiscwTox5zbkPAtOscNvAw7EiLLoKU6A8VHlRXtkp4IAAAAH1Bm3dJqEFsmUwIZ//+nhAAAEO6bzrOJB0jLGwMN900ooAywO7Xnld0580n0E+H6zvPI3GI0SXlImls3RYcfFECMW3fpoUnbhCjB1NBjeWwbiJg7i9oKPvfrynYpG+/P5+jElwPxmBV/nXx0Wi/O66V7hev6u05N2KuSNlZVgAAADpBn5VFFSwj/wAAFiKe3jc4LzxvV6I8op2Zr8aM8PoxokpEnUALbw0LhoA9yTP9MbTYU7wxERqAM29BAAAAIgGftHRH/wAAIsC437+fvEFn60geuJNC1/3X4DmparEXxPgAAAApAZ+2akf/AAAivZWtuuJaWQTPM93ZauSbqdNfVO6da+KWMQqRccS24IEAAABqQZu7SahBbJlMCGf//p4QAABBRGp0pFlAmR6J0ggLcWsWKuW3GfXr0OnjfTSHhyT+jLs5hM7gAIiLwSjlKCq9TzzEMWE5MVKSZT4nXfUlH+qUMocYKxiammPB8W8zQZrfUW8eWzP7k2yJkQAAAC9Bn9lFFSwj/wAAFZMsg/wNX7NaOg05VRJcMAA3UVHN+UaQ7Cni6OtWrOSnn41wQAAAACUBn/h0R/8AACHDO2NQ/FNoRXEbaJaPzo0+3oueQoRsitEW1SbBAAAAIQGf+mpH/wAAIbIrBwpDWii5P0T9DSwtmK/UE6EL/RK0mwAAAEVBm/9JqEFsmUwIZ//+nhAAAEFD1U8unD/oAcIm2FAFN8I6j1JWMLm9ScN8V6B16RzY3RAspnB34G19ogUyTg7jukqO8wMAAAAuQZ4dRRUsI/8AABWSnwnO7MQ/N0LSdBbsWxIU3dme/V9e7Pz3SfY9/GdZVoVTgQAAAC8Bnjx0R/8AACGsN7/cv/gWz+GZ70BDI39reas/4clr4J+RSEbP3KxaNYyoZoazCgAAACMBnj5qR/8AACGuMS/ReUOz0FBONzuju6LsilTZhriS2N2TKgAAAGZBmiNJqEFsmUwIZ//+nhAAAEFD1U8unLkyx17qrQm3sSeAFX41fhAFrt1crjEmuT84yTD09Y61nkAF5Y3Tly4t4uPUHhoTIH7G+x35a63bMjZX6bG6SLSB/X4GmvghkXwM8Pxfnl0AAAAoQZ5BRRUsI/8AABWSnqi0SQZDIYYWbblSiH0HzARYNCbu/eE0URB/xwAAACABnmB0R/8AACHAuN/BXpFlEfqB0DMW5+mVCkZXZUakVQAAACQBnmJqR/8AACGuMS/ReUOzzpOC9K39zvn1n6kNt3oNYD5vnkwAAAAvQZpnSahBbJlMCGf//p4QAABBQ9U4uMMzmAhbiXrIYx3L1Awh15H6vHaW3H5SVIkAAAAiQZ6FRRUsI/8AABWSnchZEnLtyiYuSZfclctD/YzgJwZLjwAAACIBnqR0R/8AACHAuN/BXpFlEhY+yZLncNvvTWKMX5SaNOnbAAAAKgGepmpH/wAAIa4xL9F5Q7POk4BRGG3QCloBn6iigAnAC+SenfJ8VxkLjwAAAHhBmqtJqEFsmUwIZ//+nhAAAEG6bzrOJB0PyCaxM+Gij+41n/QuCAEr+5x7IvLIX7xLZSno4eVtqQo6a0ZCkYO+kppESkebYxSxBvzZmdpwpkUxR2NCmPnakrCS24yFE27VTjhwW5E+kf4RVc9qWEl1elqL+4MwwrgAAAA1QZ7JRRUsI/8AABWVJf1MytYPb5NDru4YAMb8SmylBW2WCe4QAmNw2fWZzL2qClMpFx6jccAAAAA+AZ7odEf/AAAhwxdSg/pjxei7+ACz4ehp1PcFJChaWV4NFW9/HCE3Jev3IE5+wpCT35Om7+OkPzFSs0CHoisAAAAnAZ7qakf/AAAgrjL6/RCR8vjWI9OYTSHpTe1vzIdWI5cGpomScFyQAAAAQ0Ga70moQWyZTAhn//6eEAAAP15wxm8/u9O9QDdFOYKEW2wLCH6xJNN155qu0/z4hNjpMKeYV6AwYmF7+OQe0yxzPt8AAAAuQZ8NRRUsI/8AABUCnwnO7MQ/Nqlpw7x73NR1BapCr0MkAhiTgX2eZzCevLVWAwAAACMBnyx0R/8AACDAuaG8AE8ufVyHHFn9ZxVZ3VK6SyYBWAVOzQAAACMBny5qR/8AACCuMS/ReUOz0FBONzu9MOooh7tBQEAFGUUVgQAAAIRBmzNJqEFsmUwIZ//+nhAAAD9ef/Gbz/bKAC1t/xdZI+S+e7iuSTCzgfcCl1tpwbF+l37WuOzBGXAe/eBvRtA4LDl0g+A2YocM7REUcly3rggXAszmBtBQGvUdhdLG9BH1S7Ao1JNQkjEVWjSRg+GojvBRKFxSt/Sw8MbfDNeUKeAyGWAAAAAoQZ9RRRUsI/8AABULX0/ys+Dwp8uJiCxvp4aQ77LF1eFhP861ZlkC4AAAACMBn3B0R/8AACDAuN/BXpFlEfqB0DXxWtm+lMDZe7wzYBbOpwAAACkBn3JqR/8AACCtRkK9GtMzeemyb/11ps/gz/GCQcF3gvTiMkPDvzA3TAAAADpBm3dJqEFsmUwIX//+jLAAAEB43+Bpv40ht4U+S9V4jBhUMABWtPdt25ZdHXJJcabE9PBpbpyoBqPAAAAAIkGflUUVLCP/AAAVAp6vlJ+wmKecQs7ERSnKhLLRy836M8sAAAAiAZ+0dEf/AAAgwLjfwV6RZRIWPsjk7G6ayJGmQDp6QZM8oAAAACEBn7ZqR/8AACCuMS/ReUOzzt3Ge9uCh5bsGYuH8yKNdMEAAAB4QZu7SahBbJlMCF///oywAABAem890HjWN3YcvYqW5oKyAM/qkF0dd7s0201uxTLD/KAYvmMPewnLBWDm1n4I1N+IbwykYKgTFRslIp65RadMlvNGPYou7exjncs7krp6UDze2kghPpoIPTgbGfgXJ2wXBGccNN/7AAAAP0Gf2UUVLCP/AAAVBSTiXBCS4HtrDyk5bwdA8fAr+Ho9kmggfEja71XBjjPWgDF+1E9e3RKX8SajCX7IV1/NgAAAACsBn/h0R/8AACCsFEEF4D7DGyM7+4emLNi0MxGwbwOc9yEABOV7u1Y69l0xAAAAMAGf+mpH/wAAH7jtisw1eXH1abn8ift7YDOtXzbhL4IEnoY8AHu48JMvpDptPHV7pgAAAEBBm/5JqEFsmUwIX//+jLAAAD5cbO9x4SdaIQA3Z/ErrKoaV3Smwjya77tdJ31s6lquBM8qLy+pvp0vjEDREQTtAAAAMEGeHEUVLCP/AAAUe5RUsY/BkY4nbcQYpfgjdJis/fTJgySrK4tLGci7Qunt6Mj1sQAAACoBnj1qR/8AAB+47Ta9CGDs822QHk19eIJMziKZtYrtsqwACGQmC/LvAAgAAABJQZoiSahBbJlMCF///oywAAA+XJWJwLsHhSnEdGBTNlZvMl/G+n3bHAk4tZDp6N9ulKe2KjDljoMB1ABDLizX+3vke4exOuBJcAAAAD9BnkBFFSwj/wAAFHH9qvDdOnalqGu6opKTk+SuIIM7Z8EzooilqocAAHGeY/376s1JqOCdONyHTJK9+h6Gj20AAAAvAZ5/dEf/AAAfyMpZE1MyQ6m53Mw9Tg1TEXAxFNU3+zD7YZkvKADa+ErVmwGJHowAAAAwAZ5hakf/AAAfuO0//OLkXMwH9ZnBP35unMxAFRk6NG1kf5kjbOwxAAJqMws4jWjBAAAAVUGaZkmoQWyZTAhf//6MsAAAPrwnP2xu4QW1SmfoiOl3yLzEeADSOmfFRGtze1Z4SLvym0vGS4TyXOXspsi8yfRjYJNK33Oz6nZJJyDFfdx9SE6gCogAAAAoQZ6ERRUsI/8AABR1JOKtl0idboGf5Jd3cet4VOJiHpVFYQAuE2wHtwAAADwBnqN0R/8AAB+4e0FMBn9n8a89iz3ImvohZPVPI2yxGKqLL0seyajnqRtXhGf8AAJumBUdlQnsNtnC7tkAAAA3AZ6lakf/AAAfCaf/tERi9DpsZi7r4621AIE0fP8F9Hnjk46BpHurKpJOQ57iimL16pnGVBeCUwAAAEdBmqdJqEFsmUwIX//+jLAAADz9CmPhzMyo20J9eAAbLCd1y4Xitrl5NdRYQdCR+L8o6l3Z9asYyBdFv6Cr2zlTdefjNCYMMQAAAFBBmstJ4QpSZTAhf/6MsAAAPPykS9x5MFcxAALZz1ya9gfIdYsp/kR9gUlrJ5MJ8a+vF9cH7g/AIz/K+3sHrWmuubpxv2Wdfegmfm8bPpQSJgAAAD1BnulFNEwj/wAAE+IvCBwD+sVhJloQkrt8AyoUtPmiNlMAQAs2frsG8MQkY+FrahQhfS2xyFczn3KA9t9wAAAAPQGfCHRH/wAAHxgs/y7M6wUBd3eM7HhbeenrLCdqRACzDmM1Xaq9eATrGW+BPoyWAiQ/e2i/rkalCMVNYC0AAAAxAZ8Kakf/AAAfCO0//OLjAVnM3UwqLoy8bblWOL/DOjdNR5niI2QZxBv1VFqoZEJ8oAAAAKBBmw9JqEFomUwIX//+jLAAAD1cJ0VKZUGzpxAE+/0jlLjcNbQ/YZL6BDZlpjfb0saeubEyN1tsIH9LoTLlFj/ZyL0+t3m9yTVTdEEcRZQHgqJiwGUwllF3e9g9Wyx3bkPKtSByfx1VhFdJ5QdhAtn3H5GIOOuXX53IjzhFBaESVkULTuUIixUy98S3QoBQuxl7jvgA9ZMLr9NmWrKjLXbAAAAASkGfLUURLCP/AAAT5SU4nBGMsFftRvzPijkLKwh0FuTSO/mEwktNITcVdOovJKZbaFiSbdIBjb45rK5TZqxLjF3DvMNF3yjyOA/hAAAAMQGfTHRH/wAAHwZzFxUmy05CDdMJBJLHvZlA0l/HEpmHMmOFORpu76oNVKRgtu9AHykAAAAsAZ9Oakf/AAAeWO2K5m94cV1o22+uOoo/J8lEeM/wkfiKwrLm55dC3pbdw+8AAABzQZtRSahBbJlMFEwv//6MsAAAO+/NuljuZ856mYYTzwBT+DTjwdSQjSiNrIjuQv+MQMzekHzMKm+2wE8ts+/6HG8x5/KRczDGvEdzLQ3GwtfJk7ruEzEitajvpoyHIz6MpnwSf22uF7EqqMpNFGAITkB6EwAAAEUBn3BqR/8AAB5Y7Npw7cSGerQJvu8H2P4/lWBqcSxcOgX2Gsiusduh/tpW/o+4hFILiEF5qngBI5vhCfG3zATtunmB8oAAAABUQZtzSeEKUmUwUsL//oywAAA7nG3KADoaHgN8QX6qSPV0Nxb8cyZPD4OMUhEJSY/VuoyB5He4theWG5+lw0jn4lL796kYvGmjVTlW+HfsGwku7NEhAAAASQGfkmpH/wAAHljtNr0dngz1pvTv3ztqinXGAdKT+J+bLprmnmEOLTu2qnfGkJh5a4hVoXTO8wgAA+b+vzZhSmOrfADGBz27IpIAAAA6QZuXSeEOiZTAhf/+jLAAADv8Jz3Un1em7AgC/c+uiYUaIdc07O1fM8vZVoXeWygmz2KUz/EheomXgAAAACVBn7VFFTwj/wAAE102jLGLLpTTknsC1heHVlU+n5H318CiwQnpAAAARQGf1HRH/wAAHmgs/2Ni6ABsXecV46eeNQNMSea+tdXu7qmDvimj38IWdxfKRdMsLWsKvb6MgfRC63rffDRuDk6Zw7uYYAAAAEUBn9ZqR/8AAB5cbzde4LJEkhSSwdw/IU+WqwIDcQRIXcyrc1swITHP3FAigBLKfgzXDKPPRJbLFjF/bkV2VlUz8yu7JhkAAABPQZvZSahBaJlMFPC//oywAAA6PGzvceEnVYN/lzys6WoGvxSm1q45MzrPSg+vFIYZf9e0AFrkt5EoMX/H5iexOdXZvT30e+lpF+9Wv3QdVQAAACgBn/hqR/8AAB2o7Npw3n7bbwNBmFfzTNGLo3yR2TU8vreXy/21oToBAAAANUGb+0nhClJlMFLC//6MsAAAOjxs73HhJ1WDej7OaxleL8h7qsW2TIIAJr2o3NacUjq5AKmRAAAAJQGeGmpH/wAAHajs2nDfPDBiXfQtnO6WUrXLbNt2zWH9aZbX390AAABKQZofSeEOiZTAhf/+jLAAADqcJz3VTlXpuwdxACIuA2khfR+3BDzAjZ1vz5QYOgVlhxyBe1q23lpqVyaayhv8R0tlNggG8ysbV6EAAABAQZ49RRU8I/8AABLX8RJL6ZMQBQqxPd7XHckm4ZMLC2JfVJqr7JxVLjJBilNRmPLX6yVYZUuc19pIH9eI8tuvuQAAACwBnlx0R/8AAB2mcxcVDqCQdz1RdjYdiXaKjMrOiXIE3RQAcVKU5oO69TsUFgAAACQBnl5qR/8AABz47h3hMxDfETgu7XqpZvmTsOHQ19YqQ3x+zM0AAABSQZpBSahBaJlMFPC//oywAAA459qaPigGX1mdZQtsoRUrBhgAFSRni5+L7P8bkvVDgXDB5+rZE8ZIHi9st2H/v8Itx+igAGBJdIrBAII+e8ofQQAAACgBnmBqR/8AABz47NpxHOz85v77ZGnq7LlLUiOK1iEtUBZSwBz6ofdAAAAAXUGaZUnhClJlMCF//oywAAA5PCc/3Uwo/02m0r+oPOPsu5h1F9RM+Nex+3579bmi6vBceZbcQEjOPmNr5MHzV2zlmfEE6gut19PKYxS1lUBodGoQJfULKKjaczHEQQAAAD5BnoNFNEwj/wAAEl02lCPboGex8mjOvauORMWwCdnWLBLQ/vDbMYPsX1UgMEHa40+0qjnDvODFoZKwslhFIAAAACEBnqJ0R/8AAB0ILKKkpq4kxSYRl7etFYx2cjxRXCosikEAAAAmAZ6kakf/AAAc/IuwLi5IynvOclE3azwsgQ59eCANwwakv4f95qkAAABWQZqnSahBaJlMFPC//oywAAA3iw6iUDQCLKU3gI/hZKea3ceoibtW5/lcnMAK0Lfuqs2bMcYINtx5PCcsr8dqYSv08BgHwZ4+Zt6H8NqOoSOFdmwclrEAAAAwAZ7Gakf/AAAcSOzacN5+228NY6TpVheQh4r62pScuxO0GS+I7x6HkQAmiRAaftg5AAAAY0Gay0nhClJlMCF//oywAAA33Cc/bbu4QW1KDM7ENeywNkMqdsQoG38Q8b6JhTj1TYkhnT9BTX+LzPuV3e2gWywnC9SwYEALUd1PVZ3Y4b/34tRlJYyRpSb+Mn2cD3wF2g2QfQAAACZBnulFNEwj/wAAEdXvj4q3KwmKhYAQbaroETCuIXVgqz0kkQ6GMwAAACgBnwh0R/8AABxXblVOeghuIDdtKip6GtCiGmX0Df70nmHBL9aAhpVxAAAAOAGfCmpH/wAAHEyLsBGQs5R290y4hOSDoBk8hIrfveJ+9qxEExh18FgcIQ8pZ1WzHRRkyj6D+cFgAAAAcUGbDkmoQWiZTAhf//6MsAAANks2qJyJQ4bq7HISKWJLCRFJd8X8+8TSghNtWbQRTO/Jp9khB+IEoPTC0cyWvyAXJJgAHFVbkA10xYodU2VlAF0lwt0SpONajFm7cdUEPTk9EVlvXLwQJUu8eVYx2UyAAAAAPkGfLEURLCP/AAARXSVDQnBAVKMzdJMtz9elDlpr55aX5qDGSTD4tExiMaeN8QR/IfyAgmYg0Tz3REKdGtgtAAAAKQGfTWpH/wAAG5uDa3stDTn/bpC5o/lclYLqPRY5TG7VcSNSdbcK3gPBAAAAgkGbUkmoQWyZTAhf//6MsAAANpwnP91S5m8ddOCNHN5t1qBvHDKTr7RntQHXl/kxXy5DDG0GTQ7oQS+taFaj/PjUjJ8PDGMMxT5XPtsAFfOX962jTO7APRH1J1hWl8aVnScvkhm28gN8SsruGYE3aARQvt3x0IlcIAxHOqDjy9ipmIMAAABAQZ9wRRUsI/8AABFX8S9EEf4Udq/ETaghzw7E3J74FNwNUJXdG3Be+e5ynPYpLdO9OvJQA2XEjFuxUmqp4jW0XAAAACcBn490R/8AABuoxM9WC8U0oFGC9FtB5PBh4A2PbeS0w0mLSnOE+KQAAAAnAZ+Rakf/AAAa/F/aH0GmNlDm47lzLaNXlTmJ6W4840afYlKX3RaRAAAAf0GblEmoQWyZTBRML//+jLAAADULJpxQd1HTUYt8bJ0nOmCe+3LJem9kEkb3/vQi/G/hXuqAEVDiUp6W3kyPo91jgL+9BLTsX/7/AQclrcwIgOP1vARHq+h67AITCmuk2OIm0hXp3eoj4cHxEOa9cAcgwx7A+R2iBjqzZ7l5+k4AAAAwAZ+zakf/AAAbB5eig4DosfddNnKVYp/J7rjjRTNkJXIScYmGbgAEydrxVBY5QKeHAAAAokGbuEnhClJlMCF//oywAAA1XrZ+3m1HmFx+6s/xabt+0ZSRefdJRCdJDAQ/kwHkPC6OPUZcoE6ByMaw1CCiqPngc4xlwNgr50ogGUvq8lNAnQMf2BkrdVe4sf0fABFN17tHiK7MvyrcH60NN1i99s5b7cisX78DQMhIfbPbeJKRG/49ccAVI8SRlV8rt4gHex3SzTd0KWIub39go5h1T6/cIQAAADZBn9ZFNEwj/wAAENfxUcQSF6x2RFGIqOGTg/TMz7iRhQnVrj5u7MvbMj0CkAAsnK38L69sOZgAAAA5AZ/1dEf/AAAa/BDO+XoAgkWsFAPH31Y/3aQ9kTvrnqQW47ApHvpYq64vQX1PsolGlCc5OLo2NQ+BAAAAMQGf92pH/wAAGlvG63sr1UX1dHgTD+NgNvISWJEgNYgz941fRysihLKE1Y6aCIoRB8EAAABwQZv6SahBaJlMFPC//oywAAA0HCc90HtQVweMdd0Sbv47XwNsLhiIAidlpbEfAcbXjIu2ntPonQxOJVSSBv7DiT6nvN+9vM9FozwC0o0qroMa708GfPtZlfAUkq+HPNUED8Ru4evNShYrHohiaEP9kAAAADIBnhlqR/8AABpbg4vw54hwLjPltwe1icX4iuc01/OQhfoLc1Pwg1DaZ18EIxApaj/AeQAAAENBmhxJ4QpSZTBSwv/+jLAAADKLJqJNVc8X5Te5ComgyoRCXtpw20amNzsiXwhrJU0yAcjS3ee2noFEVxS+RrwdBPPAAAAAPQGeO2pH/wAAGbA/8PvuFkQrtAm1Mft2J98Afd+U32p+MVhwt/XE3qhSEqzVx9LVo9qktR5MTfedlnYTIXcAAABEQZo/SeEOiZTAhf/+jLAAADLcJz9t0u4QW1T8NzUzniirVwwzXpQvq+lieIkrtJjCep4a3d17gVctLhbmU6MPjwIM7IEAAAA0QZ5dRRU8I/8AAA/jfVJNXZpKIXp33GbCIjJ4ocXZwIgtIb5V+EuKAFnjwtrxr7FQcuUF4AAAACQBnn5qR/8AABm7xvBsKc40NN/+PtOhZVQ822HQpqov24Q+Wy8AAABlQZpiSahBaJlMCFf//jhAAAC+nvexenLnQFn3uHe0AOQ219E3uw+KNpiNU7TFGQ+ZsNeBNt6tDnEcbKvRBa9wcQlvD+/+LyqtNPuG7cPKxXU183W9hDIHEZJwBA65w65qpWs3LEEAAAAvQZ6ARREsI/8AAA+LejxNXZpPTpvzolaobBJXQjbYA5VLIyeqmj2ehpOFIaaBDMAAAAA3AZ6hakf/AAAZJ5eT7H3YsrQzMFQ3N6eM80J//WlZXcMTl2ELlDNmhE0rpfuhGWhKoMrLqPcxjwAAAFNBmqNJqEFsmUwIX//+jLAAADGcJz3LrTyBmWKFk8WlqcK2OFkR1E9NAh7mGeVhCRMmKXRns9WqZsfuuTNX5sJCaAClv94xtl5p42SGoHAC4RIyBgAAAHRBmsZJ4QpSZTAhX/44QAAAuccH6ViK2J/36ADmC8uLW1hvTdW1SbZDeAcMnem94XGRGA4XdNhxY3GE8992RRhCIGN8ShsN+nnACNwMPacZKgZR4GNKRZwo7I8BcaWSZf0fT4tmMneAUy/KCVT979OC4wLIYQAAADFBnuRFNEwj/wAADzN9SDA1MyRHq2tNMqIuV3jUcRp+2P8I1ey4wVHpoLBEShnmbsHpAAAAJwGfBWpH/wAAGHvHDVHnSKWLcbFJxDYDAvLctDjtzGeJwHzNXgpGeQAAAD5BmwdJqEFomUwIV//+OEAAALryfV5V0+dWeRy8notX7CeCAAjNgItOo14Pg8IxrwODbxPqyTD2F9UP/1IZBQAAAD1BmylJ4QpSZTBREsK//jhAAAC1RsGn6E54Tvt04jJzxT1WgTIUZLRFcGbUgNACEOAyupL2n/B/VrNkzZIgAAAAJwGfSGpH/wAAF9vG63uwffWXOj5zr8ZuZm3cDG2Rl20JJuinQYXxTgAAAC1Bm0pJ4Q6JlMCFf/44QAAAtUWoELZ72CTrUZIyxWEmBrsPmLydkZVcFJq0qM0AAABDQZtrSeEPJlMCFf/+OEAAALZyfVavTqZmyLIR1tROrQF2xjBADdnecYkLrCWowmQv8RKll6cid2NbSFpBRZE04ULX4gAAAEhBm41J4Q8mUwURPCv//jhAAACwxtNNhc170ciI9N2U5nefNNgm32EqepO7UMiAFmriVkOTwx8s0vRoE2XaUxvAflYWud72xO8AAAAsAZ+sakf/AAAXS11KiiXnLI3ni60wjYZ3wBvVW1IkOa11/CIW3Zgx8EcMdIUAAABtQZuuSeEPJlMCFf/+OEAAALDF0A7BQV3nGF1UJVhTpi/5cH/riyN9HDwMNDFnWOykig8ni9RYnI/HZHGxMZVN6RuPOwwd5wOnV2F2N/6YM0MD45hiLtqLUHqZFnYJrK3ZxC5I7f7XUDmHlpkJHQAAAG1Bm9BJ4Q8mUwURPCv//jhAAACx+1dk/tbK9oNGtRfzvulHxS8iIAWc5wPj8BsG8hjcvmQy2hSfZRfSgvILXm5gT6SqyD2YWLB9Ub0Nln6n1l+COAk1n2lvF8uA9hd2KcQ1ZEac8EZdlaljAcERAAAAMgGf72pH/wAAF0S2ekBVCaYogR7Av8z72OrquOvNN0a0RVvOFpxKRcHqPDblky/mahO4AAAAekGb8knhDyZTBTwr//44QAAArXtZAXRB0odMHOiFe5jF/1U4/MDoGmBBxIPVmN8INXLkt3cf0E8PqjXpr5aDpwM0AoZHyG3my9GGQm8AQ3THdI3j0V4BBJSV2DwpYmOXNTCWERId4X0lSYr0KpGMgc6IY6rXT45aKanUAAAANwGeEWpH/wAAFrGAF8mrSeuxSLspH3mL1l836XiYzF6sM/cfQnpTt9tvrIBT1GqAG3SatT7ZZcEAAABrQZoUSeEPJlMFPCf//fEAAAMBnfTIe3mTanAUjdBes9b4AISv/4k4Z6U/uyVy980FtV8v8xEIYmeM8GDssSzEvvHyUsGeqmaVgEa0FQDXw/8LGuSHXJvQgirsrCOStQ/Uxi2mKpsNub0rLmgAAAA8AZ4zakf/AAAWE7/kHpFghMwUrahygqkDN0kxpb6nX9joDeth9OOwLE/l2UUvEJ4rAqvXVAB9mc0cSdJAAAAASUGaNknhDyZTBTx//IQAAAMBbPRbw6IBn2IfAkuXgBtn04dohKGfbEJhXZ4lq0y2g4xWY0CKIqWYfXV36CC5Z0mPnFNiqy1KiHEAAAAWAZ5Vakf/AAADAS2HKbeDeOjID70j4AAAC29tb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAOTAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAKmXRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAOTAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAACWAAAAZAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAADkwAAAIAAAEAAAAAChFtZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAADIAAAC3AFXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAAAm8bWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAAJfHN0YmwAAACYc3RzZAAAAAAAAAABAAAAiGF2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAACWAGQAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY//8AAAAyYXZjQwFkAB//4QAZZ2QAH6zZQJgz5eEAAAMAAQAAAwBkDxgxlgEABmjr48siwAAAABhzdHRzAAAAAAAAAAEAAAC3AAABAAAAABRzdHNzAAAAAAAAAAEAAAABAAAFkGN0dHMAAAAAAAAAsAAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAACAAAAAAEAAAQAAAAAAgAAAQAAAAABAAACAAAAAAEAAAMAAAAAAQAAAQAAAAACAAACAAAAAAEAAAMAAAAAAQAAAQAAAAABAAACAAAAAAEAAAMAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAAcc3RzYwAAAAAAAAABAAAAAQAAALcAAAABAAAC8HN0c3oAAAAAAAAAAAAAALcAAATpAAAAeQAAACEAAAAgAAAAFwAAAIQAAAAtAAAAIAAAAB8AAABSAAAAJQAAABUAAAAiAAAAQwAAACUAAAAmAAAAHQAAAFsAAAAjAAAAEgAAACoAAABIAAAALAAAADAAAAAgAAAARwAAACUAAAAuAAAAgAAAAEQAAAA2AAAAMAAAAFMAAAAzAAAAJwAAACIAAACWAAAALgAAAC0AAAAtAAAASwAAADgAAAAjAAAAJAAAAJIAAABBAAAALgAAACcAAABNAAAALgAAACYAAAAsAAAAgQAAAD4AAAAmAAAALQAAAG4AAAAzAAAAKQAAACUAAABJAAAAMgAAADMAAAAnAAAAagAAACwAAAAkAAAAKAAAADMAAAAmAAAAJgAAAC4AAAB8AAAAOQAAAEIAAAArAAAARwAAADIAAAAnAAAAJwAAAIgAAAAsAAAAJwAAAC0AAAA+AAAAJgAAACYAAAAlAAAAfAAAAEMAAAAvAAAANAAAAEQAAAA0AAAALgAAAE0AAABDAAAAMwAAADQAAABZAAAALAAAAEAAAAA7AAAASwAAAFQAAABBAAAAQQAAADUAAACkAAAATgAAADUAAAAwAAAAdwAAAEkAAABYAAAATQAAAD4AAAApAAAASQAAAEkAAABTAAAALAAAADkAAAApAAAATgAAAEQAAAAwAAAAKAAAAFYAAAAsAAAAYQAAAEIAAAAlAAAAKgAAAFoAAAA0AAAAZwAAACoAAAAsAAAAPAAAAHUAAABCAAAALQAAAIYAAABEAAAAKwAAACsAAACDAAAANAAAAKYAAAA6AAAAPQAAADUAAAB0AAAANgAAAEcAAABBAAAASAAAADgAAAAoAAAAaQAAADMAAAA7AAAAVwAAAHgAAAA1AAAAKwAAAEIAAABBAAAAKwAAADEAAABHAAAATAAAADAAAABxAAAAcQAAADYAAAB+AAAAOwAAAG8AAABAAAAATQAAABoAAAAUc3RjbwAAAAAAAAABAAAAMAAAAGJ1ZHRhAAAAWm1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAALWlsc3QAAAAlqXRvbwAAAB1kYXRhAAAAAQAAAABMYXZmNTguMjkuMTAw\" type=\"video/mp4\" />\n",
       "             </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def dqn_main():\n",
    "  # Hyper parameters\n",
    "  lr = 1e-3\n",
    "  epochs = 500\n",
    "  start_training = 1000\n",
    "  gamma = 0.99\n",
    "  batch_size = 32\n",
    "  epsilon = 1\n",
    "  epsilon_decay = .9999\n",
    "  target_update = 1000\n",
    "  learn_frequency = 2\n",
    "\n",
    "  # Init environment\n",
    "  state_size = 4\n",
    "  action_size = 2\n",
    "  env = gym.make('CartPole-v1', render_mode=\"rgb_array\")\n",
    "\n",
    "  # Init networks\n",
    "  q_network = QNetwork(state_size, action_size).cuda()\n",
    "  target_network = QNetwork(state_size, action_size).cuda()\n",
    "  target_network.load_state_dict(q_network.state_dict())\n",
    "\n",
    "  # Init optimizer\n",
    "  optim = torch.optim.Adam(q_network.parameters(), lr=lr)\n",
    "\n",
    "  # Init replay buffer\n",
    "  memory = []\n",
    "\n",
    "  # Begin main loop\n",
    "  results_dqn = []\n",
    "  global_step = 0\n",
    "  loop = tqdm(total=epochs, position=0, leave=False)\n",
    "  for epoch in range(epochs):\n",
    "    ######################\n",
    "    last_epoch = (epoch+1 == epochs)\n",
    "    # Record the last epoch, not the previous epochs\n",
    "    if last_epoch:\n",
    "      env = wrap_env(env)\n",
    "    ######################\n",
    "\n",
    "    # Reset environment\n",
    "    state, _ = env.reset()\n",
    "    done = False\n",
    "    cum_reward = 0  # Track cumulative reward per episode\n",
    "\n",
    "    # Begin episode\n",
    "    while not done and cum_reward < 200:  # End after 200 steps \n",
    "      # Select e-greedy action\n",
    "      action, epsilon = get_action_dqn(q_network, state, epsilon, epsilon_decay)\n",
    "\n",
    "      # Take step\n",
    "      next_state, reward, terminated, truncated, _ = env.step(action)\n",
    "      done = terminated or truncated\n",
    "      # env.render()\n",
    "\n",
    "      # Store step in replay buffer\n",
    "      memory.append((state, action, next_state, reward, done))\n",
    "\n",
    "      cum_reward += reward\n",
    "      global_step += 1  # Increment total steps\n",
    "      state = next_state  # Set current state\n",
    "\n",
    "      # If time to train\n",
    "      if global_step > start_training and global_step % learn_frequency == 0:\n",
    "\n",
    "        # Sample batch\n",
    "        batch = prepare_batch(memory, batch_size)\n",
    "        \n",
    "        # Train\n",
    "        learn_dqn(batch, optim, q_network, target_network, gamma, global_step, target_update)\n",
    "    ######################\n",
    "    env.close()\n",
    "    ######################\n",
    "    # Print results at end of episode\n",
    "    results_dqn.append(cum_reward)\n",
    "    loop.update(1)\n",
    "    loop.set_description('Episodes: {} Reward: {}'.format(epoch, cum_reward))\n",
    "  \n",
    "  return results_dqn\n",
    "\n",
    "results_dqn = dqn_main()\n",
    "######################\n",
    "show_video()\n",
    "######################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 430
    },
    "id": "ZWYwytCDC3aw",
    "outputId": "33f0280e-94fd-4d27-fd65-9595d92f76a0"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(results_dqn)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qN9yy5EWVNz0"
   },
   "source": [
    "## PPO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XvRUJUew0yN_"
   },
   "source": [
    "## Part 2\n",
    "\n",
    "Proximal Policy Optimization (https://arxiv.org/pdf/1707.06347.pdf) is a type of policy gradient method. Instead of calculating Q-values, we train a network $\\pi$ to optimize the probability of taking good actions directly, using states as inputs and actions as outputs. PPO also uses a value network $V$ that estimates state values in order to estimate the advantage $\\hat{A}$. \n",
    "\n",
    "Tuples of state, action distribution, action taken, and return $(s,\\pi(s), a,\\hat{R})$ are gathered for several rollouts. After training on this experience, these tuples are discarded and new experience is gathered.\n",
    "\n",
    "Loss for the value network and the policy network are calculated according to the following formula:\n",
    "\n",
    "$Loss=ValueLoss+PolicyLoss$\n",
    "\n",
    "$ValueLoss=\\frac{1}{N}\\sum \\bigg(\\hat{R} - V(s) \\bigg)^2 $\n",
    "\n",
    "$PolicyLoss=-\\frac{1}{N}\\sum \\min\\bigg( \\frac{\\pi'(a|s)}{\\pi(a|s)} \\hat{A}, clip(\\frac{\\pi'(a|s)}{\\pi(a|s)},1-\\epsilon,1+\\epsilon) \\hat{A} \\bigg) $\n",
    "\n",
    "$\\hat{R}_t = \\sum_{i=t}^H \\gamma^{i-1}r_i$\n",
    "\n",
    "$\\hat{A}_t=\\hat{R}_t-V(s_t)$\n",
    "\n",
    "Here, $\\pi'(a|s)$ is the probability of taking an action given a state under the current policy and $\\pi(a|s)$ is the probability of taking an action given a state under the policy used to gather data. In the loss function, $a$ is the action your agent actually took and is sampled from memory. \n",
    "\n",
    "Additionally, the $clip$ function clips the value of the first argument according to the lower and upper bounds in the second and third arguments resectively.\n",
    "\n",
    "Another important note: Your the calculation of your advantage $\\hat{A}$ should not permit gradient flow from your policy loss calculation. In other words, make sure to call `.detach()` on your advantage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "id": "zsm1pILHVcEp"
   },
   "outputs": [],
   "source": [
    "def calculate_return(memory, rollout, gamma):\n",
    "  \"\"\"Return memory with calculated return in experience tuple\n",
    "\n",
    "    Args:\n",
    "        memory (list): (state, action, action_dist, return) tuples\n",
    "        rollout (list): (state, action, action_dist, reward) tuples from last rollout\n",
    "        gamma (float): discount factor\n",
    "\n",
    "    Returns:\n",
    "        list: memory updated with (state, action, action_dist, return) tuples from rollout\n",
    "  \"\"\"\n",
    "  # initialize return value\n",
    "  total_return = 0\n",
    "\n",
    "  # iterative over rollout in reverse order\n",
    "  for i in range(len(rollout)-1, -1, -1):\n",
    "      state, action, action_dist, reward = rollout[i]\n",
    "\n",
    "      # update total return\n",
    "      total_return = gamma * total_return + reward\n",
    "\n",
    "      # update memory\n",
    "      memory.append((state, action, action_dist, total_return))\n",
    "\n",
    "  return memory\n",
    "\n",
    "\n",
    "def get_action_ppo(network, state):\n",
    "  \"\"\"Sample action from the distribution obtained from the policy network\n",
    "\n",
    "    Args:\n",
    "        network (PolicyNetwork): Policy Network\n",
    "        state (np-array): current state, size (state_size)\n",
    "\n",
    "    Returns:\n",
    "        int: action sampled from output distribution of policy network\n",
    "        array: output distribution of policy network\n",
    "  \"\"\"\n",
    "  # convert state to a tensor and add a batch dimension\n",
    "  state = torch.FloatTensor(state).unsqueeze(0).cuda()\n",
    "\n",
    "  # get a tuple containing the action probabilities and the value estimate\n",
    "  with torch.no_grad():\n",
    "      action_probs = network(state)\n",
    "  # remove the batch dimension\n",
    "  action_probs = action_probs.squeeze()\n",
    "\n",
    "  # sample the probabilities to get the action\n",
    "  action = torch.multinomial(action_probs, 1)\n",
    "\n",
    "  return action.item(), action_probs.detach().cpu().numpy()\n",
    "\n",
    "\n",
    "def learn_ppo(optim, policy, value, memory_dataloader, epsilon, policy_epochs):\n",
    "  \"\"\"Implement PPO policy and value network updates. Iterate over your entire \n",
    "     memory the number of times indicated by policy_epochs.    \n",
    "\n",
    "    Args:\n",
    "        optim (Adam): value and policy optimizer\n",
    "        policy (PolicyNetwork): Policy Network\n",
    "        value (ValueNetwork): Value Network\n",
    "        memory_dataloader (DataLoader): dataloader with (state, action, action_dist, return) tensors\n",
    "        epsilon (float): trust region\n",
    "        policy_epochs (int): number of times to iterate over all memory\n",
    "  \"\"\"\n",
    "  # iterative over all memory {policy_epochs} times\n",
    "  for epoch in range(policy_epochs):\n",
    "        for state, action, old_action_probs, return_ in memory_dataloader:\n",
    "\n",
    "            # convert data types and put them on the cuda\n",
    "            state = state.float().cuda()\n",
    "            action = action.long().cuda()\n",
    "            old_action_probs = old_action_probs.float().cuda()\n",
    "            return_ = return_.float().cuda()\n",
    "\n",
    "            # Calculate advantages from old policy\n",
    "            old_value = value(state)\n",
    "            advantages = return_ - old_value.detach()\n",
    "\n",
    "            # Calculate action probabilities and entropy\n",
    "            action_probs = policy(state)\n",
    "            dist = torch.distributions.Categorical(action_probs)\n",
    "            entropy = dist.entropy()\n",
    "\n",
    "            # Calculate ratios and surrogate losses\n",
    "            new_prob = action_probs.gather(1, action.unsqueeze(-1)).squeeze(-1)\n",
    "            old_prob = old_action_probs.gather(1, action.unsqueeze(-1)).squeeze(-1)\n",
    "            # ratios\n",
    "            ratios = new_prob / old_prob\n",
    "            clipped_ratios = torch.clamp(ratios, 1 - epsilon, 1 + epsilon)\n",
    "            # surrogates\n",
    "            surrogate1 = ratios * advantages\n",
    "            surrogate2 = clipped_ratios * advantages\n",
    "            # policy\n",
    "            policy_loss = -torch.min(surrogate1, surrogate2).mean() - 0.01 * entropy.mean()\n",
    "\n",
    "            # Update policy network\n",
    "            optim.zero_grad()\n",
    "            policy_loss.backward()\n",
    "            optim.step()\n",
    "\n",
    "            # Update value network\n",
    "            new_value = value(state)\n",
    "            value_loss = F.mse_loss(return_, new_value.squeeze())\n",
    "            optim.zero_grad()\n",
    "            value_loss.backward()\n",
    "            optim.step()\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "R6RXma_-vSGX"
   },
   "source": [
    "### Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "id": "L8URnP8xvTTG"
   },
   "outputs": [],
   "source": [
    "# Dataset that wraps memory for a dataloader\n",
    "class RLDataset(Dataset):\n",
    "  def __init__(self, data):\n",
    "    super().__init__()\n",
    "    self.data = []\n",
    "    for d in data:\n",
    "      self.data.append(d)\n",
    "  \n",
    "  def __getitem__(self, index):\n",
    "    return self.data[index]\n",
    " \n",
    "  def __len__(self):\n",
    "    return len(self.data)\n",
    "\n",
    "\n",
    "# Policy Network\n",
    "class PolicyNetwork(nn.Module):\n",
    "  def __init__(self, state_size, action_size):\n",
    "    super().__init__()\n",
    "    hidden_size = 8\n",
    "    \n",
    "    self.net = nn.Sequential(nn.Linear(state_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, action_size),\n",
    "                             nn.Softmax(dim=1))\n",
    "  \n",
    "  def forward(self, x):\n",
    "    \"\"\"Get policy from state\n",
    "\n",
    "      Args:\n",
    "          state (tensor): current state, size (batch x state_size)\n",
    "\n",
    "      Returns:\n",
    "          action_dist (tensor): probability distribution over actions (batch x action_size)\n",
    "    \"\"\"\n",
    "    return self.net(x)\n",
    "  \n",
    "\n",
    "# Value Network\n",
    "class ValueNetwork(nn.Module):\n",
    "  def __init__(self, state_size):\n",
    "    super().__init__()\n",
    "    hidden_size = 8\n",
    "  \n",
    "    self.net = nn.Sequential(nn.Linear(state_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, hidden_size),\n",
    "                             nn.ReLU(),\n",
    "                             nn.Linear(hidden_size, 1))\n",
    "    \n",
    "  def forward(self, x):\n",
    "    \"\"\"Estimate value given state\n",
    "\n",
    "      Args:\n",
    "          state (tensor): current state, size (batch x state_size)\n",
    "\n",
    "      Returns:\n",
    "          value (tensor): estimated value, size (batch)\n",
    "    \"\"\"\n",
    "    return self.net(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_aBD_R_e01Qb"
   },
   "source": [
    "### Main"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "qX_Bv4M4MyY2",
    "outputId": "9e51d3e5-308e-4db7-a98c-364c7966639f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [02:55<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/202 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  24%|██▍       | 48/202 [00:00<00:00, 415.67it/s, now=None]\u001b[A\n",
      "t:  45%|████▍     | 90/202 [00:00<00:00, 363.65it/s, now=None]\u001b[A\n",
      "t:  63%|██████▎   | 127/202 [00:00<00:00, 346.57it/s, now=None]\u001b[A\n",
      "t:  80%|████████  | 162/202 [00:00<00:00, 320.75it/s, now=None]\u001b[A\n",
      "t:  97%|█████████▋| 195/202 [00:00<00:00, 315.39it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [02:56<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [02:56<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/202 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  24%|██▍       | 48/202 [00:00<00:00, 410.69it/s, now=None]\u001b[A\n",
      "t:  45%|████▍     | 90/202 [00:00<00:00, 361.13it/s, now=None]\u001b[A\n",
      "t:  63%|██████▎   | 127/202 [00:00<00:00, 332.91it/s, now=None]\u001b[A\n",
      "t:  80%|███████▉  | 161/202 [00:00<00:00, 321.71it/s, now=None]\u001b[A\n",
      "t:  96%|█████████▌| 194/202 [00:00<00:00, 300.61it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [02:57<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [02:58<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/162 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  30%|██▉       | 48/162 [00:00<00:00, 449.23it/s, now=None]\u001b[A\n",
      "t:  57%|█████▋    | 93/162 [00:00<00:00, 333.43it/s, now=None]\u001b[A\n",
      "t:  79%|███████▉  | 128/162 [00:00<00:00, 314.27it/s, now=None]\u001b[A\n",
      "t:  99%|█████████▉| 161/162 [00:00<00:00, 305.01it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [02:58<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [02:59<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-1.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-1.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/202 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  24%|██▍       | 48/202 [00:00<00:00, 444.29it/s, now=None]\u001b[A\n",
      "t:  46%|████▌     | 93/202 [00:00<00:00, 331.33it/s, now=None]\u001b[A\n",
      "t:  63%|██████▎   | 128/202 [00:00<00:00, 293.06it/s, now=None]\u001b[A\n",
      "t:  79%|███████▊  | 159/202 [00:00<00:00, 289.39it/s, now=None]\u001b[A\n",
      "t:  94%|█████████▎| 189/202 [00:00<00:00, 289.88it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:00<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-1.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:00<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-1.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-1.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/202 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  24%|██▍       | 48/202 [00:00<00:00, 418.36it/s, now=None]\u001b[A\n",
      "t:  45%|████▍     | 90/202 [00:00<00:00, 343.56it/s, now=None]\u001b[A\n",
      "t:  62%|██████▏   | 125/202 [00:00<00:00, 312.84it/s, now=None]\u001b[A\n",
      "t:  78%|███████▊  | 157/202 [00:00<00:00, 294.02it/s, now=None]\u001b[A\n",
      "t:  93%|█████████▎| 187/202 [00:00<00:00, 294.96it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:01<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-1.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:02<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-1.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-1.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/202 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  21%|██▏       | 43/202 [00:00<00:00, 428.60it/s, now=None]\u001b[A\n",
      "t:  43%|████▎     | 86/202 [00:00<00:00, 303.72it/s, now=None]\u001b[A\n",
      "t:  59%|█████▉    | 119/202 [00:00<00:00, 298.10it/s, now=None]\u001b[A\n",
      "t:  74%|███████▍  | 150/202 [00:00<00:00, 295.62it/s, now=None]\u001b[A\n",
      "t:  90%|████████▉ | 181/202 [00:00<00:00, 297.70it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:03<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-1.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:03<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-1.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-1.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/185 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  26%|██▌       | 48/185 [00:00<00:00, 423.16it/s, now=None]\u001b[A\n",
      "t:  49%|████▉     | 91/185 [00:00<00:00, 299.31it/s, now=None]\u001b[A\n",
      "t:  66%|██████▋   | 123/185 [00:00<00:00, 238.81it/s, now=None]\u001b[A\n",
      "t:  81%|████████  | 149/185 [00:00<00:00, 213.45it/s, now=None]\u001b[A\n",
      "t:  93%|█████████▎| 172/185 [00:00<00:00, 198.03it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:04<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-1.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:07<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-8.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-8.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/1 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:07<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-8.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:08<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-8.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-8.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/171 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  22%|██▏       | 38/171 [00:00<00:00, 373.42it/s, now=None]\u001b[A\n",
      "t:  44%|████▍     | 76/171 [00:00<00:00, 268.50it/s, now=None]\u001b[A\n",
      "t:  62%|██████▏   | 106/171 [00:00<00:00, 277.39it/s, now=None]\u001b[A\n",
      "t:  79%|███████▉  | 135/171 [00:00<00:00, 281.22it/s, now=None]\u001b[A\n",
      "t:  96%|█████████▌| 164/171 [00:00<00:00, 277.48it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:09<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-8.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:14<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-27.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-27.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/1 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:14<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-27.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:15<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /content/video/rl-video-episode-27.mp4.\n",
      "Moviepy - Writing video /content/video/rl-video-episode-27.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|          | 0/150 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "t:  32%|███▏      | 48/150 [00:00<00:00, 441.60it/s, now=None]\u001b[A\n",
      "t:  62%|██████▏   | 93/150 [00:00<00:00, 342.26it/s, now=None]\u001b[A\n",
      "t:  86%|████████▌ | 129/150 [00:00<00:00, 306.18it/s, now=None]\u001b[A\n",
      "Epochs: 18 Reward: 200.0:  95%|█████████▌| 19/20 [03:15<00:13, 13.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /content/video/rl-video-episode-27.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": []
    },
    {
     "data": {
      "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>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def ppo_main():\n",
    "  # Hyper parameters\n",
    "  lr = 1e-3\n",
    "  epochs = 20\n",
    "  env_samples = 100\n",
    "  gamma = 0.9\n",
    "  batch_size = 256\n",
    "  epsilon = 0.2\n",
    "  policy_epochs = 5\n",
    "\n",
    "  # Init environment \n",
    "  state_size = 4\n",
    "  action_size = 2\n",
    "  env = gym.make('CartPole-v1', render_mode=\"rgb_array\")\n",
    "\n",
    "  # Init networks\n",
    "  policy_network = PolicyNetwork(state_size, action_size).cuda()\n",
    "  value_network = ValueNetwork(state_size).cuda()\n",
    "\n",
    "  # Init optimizer\n",
    "  optim = torch.optim.Adam(chain(policy_network.parameters(), value_network.parameters()), lr=lr)\n",
    "\n",
    "  # Start main loop\n",
    "  results_ppo = []\n",
    "  loop = tqdm(total=epochs, position=0, leave=False)\n",
    "  for epoch in range(epochs):\n",
    "    ######################\n",
    "    last_epoch = (epoch+1 == epochs)\n",
    "    # Record only last epoch\n",
    "    if last_epoch:\n",
    "      env = wrap_env(env)\n",
    "    ######################\n",
    "    \n",
    "    memory = []  # Reset memory every epoch\n",
    "    rewards = []  # Calculate average episodic reward per epoch\n",
    "\n",
    "    # Begin experience loop\n",
    "    for episode in range(env_samples):\n",
    "      \n",
    "      # Reset environment\n",
    "      state, _ = env.reset()\n",
    "      done = False\n",
    "      rollout = []\n",
    "      cum_reward = 0  # Track cumulative reward\n",
    "\n",
    "      # Begin episode\n",
    "      while not done and cum_reward < 200:  # End after 200 steps   \n",
    "        # Get action\n",
    "        action, action_dist = get_action_ppo(policy_network, state)\n",
    "        \n",
    "        # Take step\n",
    "        next_state, reward, terminated, truncated, _ = env.step(action)\n",
    "        done = terminated or truncated\n",
    "        # env.render()\n",
    "\n",
    "        # Store step\n",
    "        rollout.append((state, action, action_dist, reward))\n",
    "\n",
    "        cum_reward += reward\n",
    "        state = next_state  # Set current state\n",
    "\n",
    "      # Calculate returns and add episode to memory\n",
    "      memory = calculate_return(memory, rollout, gamma)\n",
    "\n",
    "      rewards.append(cum_reward)\n",
    "      ######################\n",
    "      env.close()\n",
    "      ######################\n",
    "    # Train\n",
    "    dataset = RLDataset(memory)\n",
    "    loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
    "    learn_ppo(optim, policy_network, value_network, loader, epsilon, policy_epochs)\n",
    "    \n",
    "    # Print results\n",
    "    results_ppo.extend(rewards)  # Store rewards for this epoch\n",
    "    loop.update(1)\n",
    "    loop.set_description(\"Epochs: {} Reward: {}\".format(epoch, results_ppo[-1]))\n",
    "\n",
    "  return results_ppo\n",
    "\n",
    "results_ppo = ppo_main()\n",
    "######################\n",
    "show_video()\n",
    "######################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 430
    },
    "id": "pLXetCMpC1DE",
    "outputId": "2ead83e8-c9ca-4b46-e35c-020c7e60ae94"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(results_ppo)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wHkJqFlnUS9F"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "provenance": []
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}