02.PPO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "copMmhVRffM4"
   },
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bl_x5UTeffM5",
    "outputId": "61c92c99-749d-4983-babb-dd3092ddd54c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting gymnasium==1.0.0\n",
      "  Downloading gymnasium-1.0.0-py3-none-any.whl.metadata (9.5 kB)\n",
      "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (1.26.4)\n",
      "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (3.1.0)\n",
      "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (4.12.2)\n",
      "Collecting farama-notifications>=0.0.1 (from gymnasium==1.0.0)\n",
      "  Downloading Farama_Notifications-0.0.4-py3-none-any.whl.metadata (558 bytes)\n",
      "Downloading gymnasium-1.0.0-py3-none-any.whl (958 kB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m958.1/958.1 kB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hDownloading Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n",
      "Installing collected packages: farama-notifications, gymnasium\n",
      "Successfully installed farama-notifications-0.0.4 gymnasium-1.0.0\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !pip install gymnasium==1.0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gKgQ5FvjffM6"
   },
   "source": [
    "# 02. PPO\n",
    "\n",
    "- PPO: [J. Schulman et al., \"Proximal Policy Optimization Algorithms.\" arXiv preprint arXiv:1707.06347, 2017.](https://arxiv.org/abs/1707.06347.pdf)\n",
    "- TRPO: [Schulman, John, et al. \"Trust region policy optimization.\" International conference on machine learning. 2015.](http://proceedings.mlr.press/v37/schulman15.pdf)\n",
    "\n",
    "There are two kinds of algorithms of PPO: PPO-Penalty and PPO-Clip. Here, we'll implement PPO-clip version.\n",
    "\n",
    "TRPO computes the gradients with a complex second-order method. On the other hand, PPO tries to solve the problem with a first-order methods that keep new policies close to old. To simplify the surrogate objective, let $r(\\theta)$ denote the probability ratio\n",
    "\n",
    "$$ L^{CPI}(\\theta) = \\hat {\\mathbb{E}}_t \\left [ {\\pi_\\theta(a_t|s_t) \\over \\pi_{\\theta_{old}}(a_t|s_t)} \\hat A_t\\right] = \\hat {\\mathbb{E}}_t \\left [ r_t(\\theta) \\hat A_t \\right ].$$\n",
    "\n",
    "The objective is penalized further away from $r_t(\\theta)$\n",
    "\n",
    "$$ L^{CLIP}(\\theta)=\\hat {\\mathbb{E}}_t \\left [ \\min(r_t(\\theta) \\hat A_t, \\text{clip}(r_t(\\theta), 1-\\epsilon, 1+\\epsilon)\\hat A_t) \\right ] $$\n",
    "\n",
    "If the advantage is positive, the objective will increase. As a result, the action becomes more likely. If advantage is negative, the objective will decrease. AS a result, the action becomes less likely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "humfBm2yffM6"
   },
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "r6YSg5W-ffM6"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xIV7-fRFffM7"
   },
   "source": [
    "## Network\n",
    "We will use two separated networks for actor and critic respectively. The actor network consists of two fully connected hidden layer with ReLU branched out two fully connected output layers for mean and standard deviation of Gaussian distribution. Pendulum-v0 has only one action which has a range from -2 to 2. In order to fit the range, the actor outputs the mean value with tanh. The result will be scaled in ActionNormalizer class. On the one hand, the critic network has three fully connected layers as two hidden layers (ReLU) and an output layer. One thing to note is that we initialize the last layers' weights and biases as uniformly distributed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "WmJoxbWTffM7"
   },
   "outputs": [],
   "source": [
    "def init_layer_uniform(layer: nn.Linear, init_w: float = 3e-3) -> nn.Linear:\n",
    "    \"\"\"Init uniform parameters on the single layer.\"\"\"\n",
    "    layer.weight.data.uniform_(-init_w, init_w)\n",
    "    layer.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    return layer\n",
    "\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        in_dim: int,\n",
    "        out_dim: int,\n",
    "        log_std_min: int = -20,\n",
    "        log_std_max: int = 0,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        self.hidden = nn.Linear(in_dim, 32)\n",
    "\n",
    "        self.mu_layer = nn.Linear(32, out_dim)\n",
    "        self.mu_layer = init_layer_uniform(self.mu_layer)\n",
    "\n",
    "        self.log_std_layer = nn.Linear(32, out_dim)\n",
    "        self.log_std_layer = init_layer_uniform(self.log_std_layer)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden(state))\n",
    "\n",
    "        mu = torch.tanh(self.mu_layer(x))\n",
    "        log_std = torch.tanh(self.log_std_layer(x))\n",
    "        log_std = self.log_std_min + 0.5 * (self.log_std_max - self.log_std_min) * (log_std + 1)\n",
    "        std = torch.exp(log_std)\n",
    "\n",
    "        dist = Normal(mu, std)\n",
    "        action = dist.sample()\n",
    "\n",
    "        return action, dist\n",
    "\n",
    "\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "\n",
    "        self.hidden = nn.Linear(in_dim, 64)\n",
    "        self.out = nn.Linear(64, 1)\n",
    "        self.out = init_layer_uniform(self.out)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden(state))\n",
    "        value = self.out(x)\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "do1RGiWJffM7"
   },
   "source": [
    "## GAE\n",
    "\n",
    "*GAE* help to reduce variance while maintaining a proper level of bias. By adjusting parameters $\\lambda \\in [0, 1]$ and $\\gamma \\in [0, 1]$. Please see [the paper](https://arxiv.org/pdf/1506.02438) for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "ueKVv6U-ffM7"
   },
   "outputs": [],
   "source": [
    "def compute_gae(\n",
    "    next_value: list, rewards: list, masks: list, values: list, gamma: float, tau: float\n",
    ") -> List:\n",
    "    \"\"\"Compute gae.\"\"\"\n",
    "    values = values + [next_value]\n",
    "    gae = 0\n",
    "    returns: Deque[float] = deque()\n",
    "\n",
    "    for step in reversed(range(len(rewards))):\n",
    "        delta = rewards[step] + gamma * values[step + 1] * masks[step] - values[step]\n",
    "        gae = delta + gamma * tau * masks[step] * gae\n",
    "        returns.appendleft(gae + values[step])\n",
    "\n",
    "    return list(returns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YiTRVsblffM7"
   },
   "source": [
    "## PPO Agent\n",
    "Here is a summary of PPOAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                   |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|_plot             | plot the training progresses.                        |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q9kslZOxffM7"
   },
   "source": [
    "PPO updates the model several times(`epoch`) using the stacked memory. By `ppo_iter` function, It yield the samples of stacked memory by interacting a environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "ADyte0QjffM8"
   },
   "outputs": [],
   "source": [
    "def ppo_iter(\n",
    "    epoch: int,\n",
    "    mini_batch_size: int,\n",
    "    states: torch.Tensor,\n",
    "    actions: torch.Tensor,\n",
    "    values: torch.Tensor,\n",
    "    log_probs: torch.Tensor,\n",
    "    returns: torch.Tensor,\n",
    "    advantages: torch.Tensor,\n",
    "):\n",
    "    \"\"\"Yield mini-batches.\"\"\"\n",
    "    batch_size = states.size(0)\n",
    "    for _ in range(epoch):\n",
    "        for _ in range(batch_size // mini_batch_size):\n",
    "            rand_ids = np.random.choice(batch_size, mini_batch_size)\n",
    "            yield states[rand_ids, :], actions[rand_ids], values[rand_ids], log_probs[\n",
    "                rand_ids\n",
    "            ], returns[rand_ids], advantages[rand_ids]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ggQkRfejffM8"
   },
   "outputs": [],
   "source": [
    "class PPOAgent:\n",
    "    \"\"\"PPO Agent.\n",
    "    Attributes:\n",
    "        env (gym.Env): Gym env for training\n",
    "        gamma (float): discount factor\n",
    "        tau (float): lambda of generalized advantage estimation (GAE)\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): amount of clipping surrogate objective\n",
    "        epoch (int): the number of update\n",
    "        rollout_len (int): the number of rollout\n",
    "        entropy_weight (float): rate of weighting entropy into the loss function\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        device (torch.device): cpu / gpu\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "        seed (int): random seed\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        batch_size: int,\n",
    "        gamma: float,\n",
    "        tau: float,\n",
    "        epsilon: float,\n",
    "        epoch: int,\n",
    "        rollout_len: int,\n",
    "        entropy_weight: float,\n",
    "        seed: int = 777,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = epsilon\n",
    "        self.epoch = epoch\n",
    "        self.rollout_len = rollout_len\n",
    "        self.entropy_weight = entropy_weight\n",
    "        self.seed = seed\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "\n",
    "        # networks\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.critic = Critic(obs_dim).to(self.device)\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=0.001)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=0.005)\n",
    "\n",
    "        # memory for training\n",
    "        self.states: List[torch.Tensor] = []\n",
    "        self.actions: List[torch.Tensor] = []\n",
    "        self.rewards: List[torch.Tensor] = []\n",
    "        self.values: List[torch.Tensor] = []\n",
    "        self.masks: List[torch.Tensor] = []\n",
    "        self.log_probs: List[torch.Tensor] = []\n",
    "\n",
    "        # total steps count\n",
    "        self.total_step = 1\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        state = torch.FloatTensor(state).to(self.device)\n",
    "        action, dist = self.actor(state)\n",
    "        selected_action = dist.mean if self.is_test else action\n",
    "\n",
    "        if not self.is_test:\n",
    "            value = self.critic(state)\n",
    "            self.states.append(state)\n",
    "            self.actions.append(selected_action)\n",
    "            self.values.append(value)\n",
    "            self.log_probs.append(dist.log_prob(selected_action))\n",
    "\n",
    "        return selected_action.cpu().detach().numpy()\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "        next_state = np.reshape(next_state, (1, -1)).astype(np.float64)\n",
    "        reward = np.reshape(reward, (1, -1)).astype(np.float64)\n",
    "        done = np.reshape(done, (1, -1))\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.rewards.append(torch.FloatTensor(reward).to(self.device))\n",
    "            self.masks.append(torch.FloatTensor(1 - done).to(self.device))\n",
    "\n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self, next_state: np.ndarray) -> Tuple[float, float]:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        next_state = torch.FloatTensor(next_state).to(self.device)\n",
    "        next_value = self.critic(next_state)\n",
    "\n",
    "        returns = compute_gae(\n",
    "            next_value,\n",
    "            self.rewards,\n",
    "            self.masks,\n",
    "            self.values,\n",
    "            self.gamma,\n",
    "            self.tau,\n",
    "        )\n",
    "\n",
    "        states = torch.cat(self.states).view(-1, 3)\n",
    "        actions = torch.cat(self.actions)\n",
    "        returns = torch.cat(returns).detach()\n",
    "        values = torch.cat(self.values).detach()\n",
    "        log_probs = torch.cat(self.log_probs).detach()\n",
    "        advantages = returns - values\n",
    "\n",
    "        actor_losses, critic_losses = [], []\n",
    "\n",
    "        for state, action, old_value, old_log_prob, return_, adv in ppo_iter(\n",
    "            epoch=self.epoch,\n",
    "            mini_batch_size=self.batch_size,\n",
    "            states=states,\n",
    "            actions=actions,\n",
    "            values=values,\n",
    "            log_probs=log_probs,\n",
    "            returns=returns,\n",
    "            advantages=advantages,\n",
    "        ):\n",
    "            # calculate ratios\n",
    "            _, dist = self.actor(state)\n",
    "            log_prob = dist.log_prob(action)\n",
    "            ratio = (log_prob - old_log_prob).exp()\n",
    "\n",
    "            # actor_loss\n",
    "            surr_loss = ratio * adv\n",
    "            clipped_surr_loss = torch.clamp(ratio, 1.0 - self.epsilon, 1.0 + self.epsilon) * adv\n",
    "\n",
    "            # entropy\n",
    "            entropy = dist.entropy().mean()\n",
    "\n",
    "            actor_loss = (\n",
    "                -torch.min(surr_loss, clipped_surr_loss).mean() - entropy * self.entropy_weight\n",
    "            )\n",
    "\n",
    "            # critic_loss\n",
    "            value = self.critic(state)\n",
    "            # clipped_value = old_value + (value - old_value).clamp(-0.5, 0.5)\n",
    "            critic_loss = (return_ - value).pow(2).mean()\n",
    "\n",
    "            # train critic\n",
    "            self.critic_optimizer.zero_grad()\n",
    "            critic_loss.backward(retain_graph=True)\n",
    "            self.critic_optimizer.step()\n",
    "\n",
    "            # train actor\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            self.actor_optimizer.step()\n",
    "\n",
    "            actor_losses.append(actor_loss.item())\n",
    "            critic_losses.append(critic_loss.item())\n",
    "\n",
    "        self.states, self.actions, self.rewards = [], [], []\n",
    "        self.values, self.masks, self.log_probs = [], [], []\n",
    "\n",
    "        actor_loss = sum(actor_losses) / len(actor_losses)\n",
    "        critic_loss = sum(critic_losses) / len(critic_losses)\n",
    "\n",
    "        return actor_loss, critic_loss\n",
    "\n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "\n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        state = np.expand_dims(state, axis=0)\n",
    "\n",
    "        actor_losses, critic_losses = [], []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        while self.total_step <= num_frames + 1:\n",
    "            for _ in range(self.rollout_len):\n",
    "                self.total_step += 1\n",
    "                action = self.select_action(state)\n",
    "                next_state, reward, done = self.step(action)\n",
    "\n",
    "                state = next_state\n",
    "                score += reward[0][0]\n",
    "\n",
    "                # if episode ends\n",
    "                if done[0][0]:\n",
    "                    state, _ = self.env.reset(seed=self.seed)\n",
    "                    state = np.expand_dims(state, axis=0)\n",
    "                    scores.append(score)\n",
    "                    score = 0\n",
    "\n",
    "                    self._plot(self.total_step, scores, actor_losses, critic_losses)\n",
    "\n",
    "            actor_loss, critic_loss = self.update_model(next_state)\n",
    "            actor_losses.append(actor_loss)\n",
    "            critic_losses.append(critic_loss)\n",
    "\n",
    "        # termination\n",
    "        self.env.close()\n",
    "\n",
    "    def test(self, video_folder: str):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "\n",
    "        tmp_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "\n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "\n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "        self.env = tmp_env\n",
    "\n",
    "    def _plot(\n",
    "        self,\n",
    "        frame_idx: int,\n",
    "        scores: List[float],\n",
    "        actor_losses: List[float],\n",
    "        critic_losses: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iA82selSffM8"
   },
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "xs4T5-CgffM8"
   },
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nTEh0ABIffM8"
   },
   "source": [
    "You can see [the code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/pendulum.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/e73245912087d47b538dcdb45fa9a9d185b805c5/gymnasium/envs/__init__.py#L41) of Pendulum-v1 from Gymnasyim repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "IrYbor8-ffM8"
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2pHo9rn5gScQ"
   },
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "N7ApXHQ7gRyA"
   },
   "outputs": [],
   "source": [
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "\n",
    "seed = 777\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KvHO1op6ffM8"
   },
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "k28cwIQ1ffM8",
    "outputId": "cdb6569f-71e9-4f56-924f-0fa6ecd6344b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 60000\n",
    "\n",
    "agent = PPOAgent(\n",
    "    env,\n",
    "    gamma=0.9,\n",
    "    tau=0.8,\n",
    "    batch_size=64,\n",
    "    epsilon=0.2,\n",
    "    epoch=64,\n",
    "    rollout_len=2048,\n",
    "    entropy_weight=0.005,\n",
    "    seed=seed,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yyuh81I_ffM9"
   },
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 318
    },
    "id": "JaGm_BeEffM9",
    "outputId": "ded7eaa8-4d9d-48ba-b7ff-226edeaa54c5"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Rc5lTEZoffM9"
   },
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QW7EppwEffM9",
    "outputId": "e19786dd-ce6f-440a-9014-cd04e96d7ac1"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/gymnasium/envs/classic_control/pendulum.py:218: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  c = pygame.math.Vector2(c).rotate_rad(self.state[0] + np.pi / 2)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  [[-135.54652568]]\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "video_folder = \"videos/ppo\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MXjioRpmffM9"
   },
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 279
    },
    "id": "2eKCKKDmffM9",
    "outputId": "3fd669bd-098e-4da5-8078-2d41fad7ec39"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/ppo/rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(\n",
    "        HTML(\n",
    "            data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(\n",
    "                encoded.decode(\"ascii\")\n",
    "            )\n",
    "        )\n",
    "    )\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "czvlod3RffM9"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "pgayn",
   "language": "python",
   "name": "pgayn"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}