07.BC.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j9LNaRxZgxPI"
      },
      "source": [
        "## Configuration for Colab"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G7UXG9jmgxPJ",
        "outputId": "ef97bdd9-1450-49e2-92c9-6d5bece3dcbe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting gymnasium==1.0.0\n",
            "  Downloading gymnasium-1.0.0-py3-none-any.whl.metadata (9.5 kB)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (1.26.4)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (3.1.0)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (4.12.2)\n",
            "Collecting farama-notifications>=0.0.1 (from gymnasium==1.0.0)\n",
            "  Downloading Farama_Notifications-0.0.4-py3-none-any.whl.metadata (558 bytes)\n",
            "Downloading gymnasium-1.0.0-py3-none-any.whl (958 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m958.1/958.1 kB\u001b[0m \u001b[31m11.8 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": "7DenbzNrgxPJ"
      },
      "source": [
        "# 07. Behavior Cloning (without HER)\n",
        "\n",
        "[A. Nair et al., \"Overcoming Exploration in Reinforcement Learning with Demonstrations.\" arXiv preprint arXiv:1709.10089, 2017.](https://arxiv.org/pdf/1709.10089.pdf)\n",
        "\n",
        "Exploration in environments with sparse rewards has been a persistent problem in reinforcement learning. Many tasks are natural to  specify with a sparse reward, and manually shaping a reward function can result in suboptimal performance. However, finding a non-zero reward is exponentially more difficult with increasing task horizon or action dimensionality. In  this  paper, the authors use demonstrations to overcome the exploration problem and successfully learn to perform long-horizon, multi-step tasks with continuous control such as stacking blocks with a robot arm.\n",
        "\n",
        "### DDPG\n",
        "For learning in high-dimentional and continous action spaces, the authors of DDPG combine the actor-critic approach with insights from the recent success of DQN. Deep DPG(DDPG) is based on the deterministic policy gradient(DPG) algorithm ([Silver et al., 2014](http://proceedings.mlr.press/v32/silver14.pdf)). Please see *03.DDPG.ipynb* for detailed description of DDPG.\n",
        "\n",
        "### Demonstration Buffer\n",
        "It maintains a second replay buffer $R_D$ where we store our the demonstration data in the same format as the original replay buffer $R$. In each minibatch, we draw extra $N_D$ examples from $R_D$ to use as off-policy replay data for the update step. These examples are included in both the actor and critic update.\n",
        "\n",
        "### Behavior Cloning Loss\n",
        "It computes only on the demonstration examples for training the actor.\n",
        "$$\n",
        "L_{BC} = \\underset{i=1}{\\overset{N_D}\\sum} \\lVert \\pi (s_i | \\theta_\\pi) - a_i \\rVert^2\n",
        "$$\n",
        "This loss is a standard loss in imitation learning, but this paper shows that using it as an auxiliary loss for RL improves learning significantly. The gradient applied to the actor parameters $\\theta_\\pi$ is:\n",
        "$$\n",
        "L_A = - \\lambda_1 \\nabla_{\\theta_{\\pi}}J + \\lambda_2 \\nabla_{\\theta_{\\pi}} L_{BC}\n",
        "$$\n",
        "Two parameters called  $\\lambda_1$ ,  $\\lambda_2$  are used to weight the contributions.\n",
        "\n",
        "### Q-Filter\n",
        "Using the above loss prevents the learned policy from improving significantly beyond the demonstration policy, as the actor is always tied back to the demonstrations. To avoid this problem, the authors apply the behavior cloning loss only to states where the critic $Q(s,a)$ determines that action of the demonstration is better than actor's action:\n",
        "$$\n",
        "L_{BC} = \\underset{i=1}{\\overset{N_D}\\sum}\\lVert \\pi (s_i | \\theta_\\pi) - a_i \\rVert^2 \\mathbb{1}_{Q(s_i, a_i) > Q(s_i, \\pi(s_i))}\n",
        "$$\n",
        "\n",
        "### Hindsight Experience Replay (HER)\n",
        "The key insight of HER is that even in failed rollouts where no reward was obtained, the agent can transform them into successful ones by assuming that a state it saw in the rollout was the actual goal. It can be used with any off-policy RL algorithm assuming that for every state we can find a goal corresponding to this state.\n",
        "However, it needs parametrized goals setting, which can be sampled the goal $g$ at the beginning of every episode, so **we don't implement it**. Please see [this paper](https://arxiv.org/pdf/1707.01495) for detailed contents."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qyQCjF7mgxPK"
      },
      "source": [
        "## Import modules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J7c3xdJwgxPK",
        "outputId": "a5818b38-8427-41be-dde1-0c4612fff5c9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-12-30 11:29:25--  https://raw.githubusercontent.com/mrsyee/pg-is-all-you-need/master/demo.pkl\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 179797 (176K) [application/octet-stream]\n",
            "Saving to: ‘demo.pkl’\n",
            "\n",
            "\rdemo.pkl              0%[                    ]       0  --.-KB/s               \rdemo.pkl            100%[===================>] 175.58K  --.-KB/s    in 0.03s   \n",
            "\n",
            "2024-12-30 11:29:25 (5.25 MB/s) - ‘demo.pkl’ saved [179797/179797]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import copy\n",
        "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",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "if IN_COLAB and not os.path.exists(\"demo.pkl\"):\n",
        "    # download demo.pkl\n",
        "    !wget https://raw.githubusercontent.com/mrsyee/pg-is-all-you-need/master/demo.pkl"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-TWK5lT1gxPK"
      },
      "source": [
        "## Replay buffer\n",
        "Typically, people implement replay buffers with one of the following three data structures:\n",
        "\n",
        "- collections.deque\n",
        "- list\n",
        "- numpy.ndarray\n",
        "\n",
        "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
        "\n",
        "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
        "\n",
        "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
        "\n",
        "In addition, we add `extend` method to store multi transitions like demonstration.\n",
        "\n",
        "Reference:\n",
        "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
        "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "tTFyc75_gxPK"
      },
      "outputs": [],
      "source": [
        "class ReplayBuffer:\n",
        "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
        "\n",
        "    def __init__(self, obs_dim: int, act_dim: int, size: int, batch_size: int = 32):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
        "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
        "        self.acts_buf = np.zeros([size, act_dim], dtype=np.float32)\n",
        "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
        "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
        "        self.max_size, self.batch_size = size, batch_size\n",
        "        self.ptr, self.size = 0, 0\n",
        "\n",
        "    def store(\n",
        "        self,\n",
        "        obs: np.ndarray,\n",
        "        act: np.ndarray,\n",
        "        rew: float,\n",
        "        next_obs: np.ndarray,\n",
        "        done: bool,\n",
        "    ):\n",
        "        \"\"\"Store the transition in buffer.\"\"\"\n",
        "        self.obs_buf[self.ptr] = obs\n",
        "        self.next_obs_buf[self.ptr] = next_obs\n",
        "        self.acts_buf[self.ptr] = act\n",
        "        self.rews_buf[self.ptr] = rew\n",
        "        self.done_buf[self.ptr] = done\n",
        "        self.ptr = (self.ptr + 1) % self.max_size\n",
        "        self.size = min(self.size + 1, self.max_size)\n",
        "\n",
        "    def extend(\n",
        "        self,\n",
        "        transitions: List[Tuple],\n",
        "    ):\n",
        "        \"\"\"Store the multi transitions in buffer.\"\"\"\n",
        "        for transition in transitions:\n",
        "            self.store(*transition)\n",
        "\n",
        "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
        "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
        "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
        "        return dict(\n",
        "            obs=self.obs_buf[idxs],\n",
        "            next_obs=self.next_obs_buf[idxs],\n",
        "            acts=self.acts_buf[idxs],\n",
        "            rews=self.rews_buf[idxs],\n",
        "            done=self.done_buf[idxs],\n",
        "        )\n",
        "\n",
        "    def __len__(self) -> int:\n",
        "        return self.size"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fUixJS5AgxPL"
      },
      "source": [
        "## OU Noise\n",
        "*Ornstein-Uhlenbeck* process generates temporally correlated exploration, and it effectively copes with physical control problems of inertia.\n",
        "\n",
        "$$\n",
        "dx_t = \\theta(\\mu - x_t) dt + \\sigma dW_t\n",
        "$$\n",
        "\n",
        "Reference:\n",
        "- [Udacity github](https://github.com/udacity/deep-reinforcement-learning/blob/master/ddpg-pendulum/ddpg_agent.py)\n",
        "- [Wiki](https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "mRD35YqygxPL"
      },
      "outputs": [],
      "source": [
        "class OUNoise:\n",
        "    \"\"\"Ornstein-Uhlenbeck process.\n",
        "    Taken from Udacity deep-reinforcement-learning github repository:\n",
        "    https://github.com/udacity/deep-reinforcement-learning/blob/master/\n",
        "    ddpg-pendulum/ddpg_agent.py\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        size: int,\n",
        "        mu: float = 0.0,\n",
        "        theta: float = 0.15,\n",
        "        sigma: float = 0.2,\n",
        "    ):\n",
        "        \"\"\"Initialize parameters and noise process.\"\"\"\n",
        "        self.state = np.float64(0.0)\n",
        "        self.mu = mu * np.ones(size)\n",
        "        self.theta = theta\n",
        "        self.sigma = sigma\n",
        "        self.reset()\n",
        "\n",
        "    def reset(self):\n",
        "        \"\"\"Reset the internal state (= noise) to mean (mu).\"\"\"\n",
        "        self.state = copy.copy(self.mu)\n",
        "\n",
        "    def sample(self) -> np.ndarray:\n",
        "        \"\"\"Update internal state and return it as a noise sample.\"\"\"\n",
        "        x = self.state\n",
        "        dx = self.theta * (self.mu - x) + self.sigma * np.array(\n",
        "            [random.random() for _ in range(len(x))]\n",
        "        )\n",
        "        self.state = x + dx\n",
        "        return self.state"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ngykpdBkgxPL"
      },
      "source": [
        "## Network\n",
        "We are going to use two separated networks for actor and critic. The actor network has three fully connected layers and three non-linearity functions, *ReLU* for hidden layers and *tanh* for the output layer. On the other hand, the critic network has three fully connected layers, but it used two activation functions for hidden layers *ReLU*. Plus, its input sizes of critic network are sum of state sizes and action sizes. One thing to note is that we initialize the final layer's weights and biases so that they are *uniformly distributed.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "0nS44hiTgxPL"
      },
      "outputs": [],
      "source": [
        "class Actor(nn.Module):\n",
        "    def __init__(\n",
        "        self,\n",
        "        in_dim: int,\n",
        "        out_dim: int,\n",
        "        init_w: float = 3e-3,\n",
        "    ):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        super(Actor, self).__init__()\n",
        "\n",
        "        self.hidden1 = nn.Linear(in_dim, 128)\n",
        "        self.hidden2 = nn.Linear(128, 128)\n",
        "        self.out = nn.Linear(128, out_dim)\n",
        "\n",
        "        self.out.weight.data.uniform_(-init_w, init_w)\n",
        "        self.out.bias.data.uniform_(-init_w, init_w)\n",
        "\n",
        "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Forward method implementation.\"\"\"\n",
        "        x = F.relu(self.hidden1(state))\n",
        "        x = F.relu(self.hidden2(x))\n",
        "        action = self.out(x).tanh()\n",
        "\n",
        "        return action\n",
        "\n",
        "\n",
        "class Critic(nn.Module):\n",
        "    def __init__(\n",
        "        self,\n",
        "        in_dim: int,\n",
        "        init_w: float = 3e-3,\n",
        "    ):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        super(Critic, self).__init__()\n",
        "\n",
        "        self.hidden1 = nn.Linear(in_dim, 128)\n",
        "        self.hidden2 = nn.Linear(128, 128)\n",
        "        self.out = nn.Linear(128, 1)\n",
        "\n",
        "        self.out.weight.data.uniform_(-init_w, init_w)\n",
        "        self.out.bias.data.uniform_(-init_w, init_w)\n",
        "\n",
        "    def forward(self, state: torch.Tensor, action: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Forward method implementation.\"\"\"\n",
        "        x = torch.cat((state, action), dim=-1)\n",
        "        x = F.relu(self.hidden1(x))\n",
        "        x = F.relu(self.hidden2(x))\n",
        "        value = self.out(x)\n",
        "\n",
        "        return value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4BOWfTozgxPL"
      },
      "source": [
        "## BC Agent\n",
        "Here is a summary of BCAgent 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",
        "|\\_target_soft_update| soft update from the local model to the target model.|"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "qkKmQNBBgxPL"
      },
      "outputs": [],
      "source": [
        "class BCAgent:\n",
        "    \"\"\"BCAgent interacting with environment.\n",
        "\n",
        "    Attribute:\n",
        "        env (gym.Env): openAI Gym environment\n",
        "        actor (nn.Module): target actor model to select actions\n",
        "        actor_target (nn.Module): actor model to predict next actions\n",
        "        actor_optimizer (Optimizer): optimizer for training actor\n",
        "        critic (nn.Module): critic model to predict state values\n",
        "        critic_target (nn.Module): target critic model to predict state values\n",
        "        critic_optimizer (Optimizer): optimizer for training critic\n",
        "        memory (ReplayBuffer): replay memory to store transitions\n",
        "        demo_memory (ReplayBuffer): replay memory for demonstration\n",
        "        batch_size (int): batch size for sampling\n",
        "        gamma (float): discount factor\n",
        "        tau (float): parameter for soft target update\n",
        "        initial_random_steps (int): initial random action steps\n",
        "        lambda1 (float): weight for policy gradient loss\n",
        "        lambda2 (float): weight for behavior cloning loss\n",
        "        noise (OUNoise): noise generator for exploration\n",
        "        device (torch.device): cpu / gpu\n",
        "        transition (list): temporory storage for the recent transition\n",
        "        total_step (int): total step numbers\n",
        "        is_test (bool): flag to show the current mode (train / test)\n",
        "        seed (int): random seed\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        env: gym.Env,\n",
        "        memory_size: int,\n",
        "        batch_size: int,\n",
        "        demo_batch_size: int,\n",
        "        ou_noise_theta: float,\n",
        "        ou_noise_sigma: float,\n",
        "        demo: list,\n",
        "        gamma: float = 0.99,\n",
        "        tau: float = 5e-3,\n",
        "        initial_random_steps: int = 1e4,\n",
        "        seed: int = 777,\n",
        "        # loss parameters\n",
        "        lambda1: float = 1e-3,\n",
        "        lambda2: int = 1.0,\n",
        "    ):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        obs_dim = env.observation_space.shape[0]\n",
        "        action_dim = env.action_space.shape[0]\n",
        "\n",
        "        self.env = env\n",
        "        self.batch_size = batch_size\n",
        "        self.gamma = gamma\n",
        "        self.tau = tau\n",
        "        self.initial_random_steps = initial_random_steps\n",
        "        self.seed = seed\n",
        "\n",
        "        # loss parameters\n",
        "        self.lambda1 = lambda1\n",
        "        self.lambda2 = lambda2 / demo_batch_size\n",
        "\n",
        "        # buffer\n",
        "        self.memory = ReplayBuffer(obs_dim, action_dim, memory_size, batch_size)\n",
        "\n",
        "        # demo buffer\n",
        "        self.demo_memory = ReplayBuffer(obs_dim, action_dim, len(demo), demo_batch_size)\n",
        "        self.demo_memory.extend(demo)\n",
        "\n",
        "        # noise\n",
        "        self.noise = OUNoise(\n",
        "            action_dim,\n",
        "            theta=ou_noise_theta,\n",
        "            sigma=ou_noise_sigma,\n",
        "        )\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",
        "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
        "        self.actor_target = Actor(obs_dim, action_dim).to(self.device)\n",
        "        self.actor_target.load_state_dict(self.actor.state_dict())\n",
        "\n",
        "        self.critic = Critic(obs_dim + action_dim).to(self.device)\n",
        "        self.critic_target = Critic(obs_dim + action_dim).to(self.device)\n",
        "        self.critic_target.load_state_dict(self.critic.state_dict())\n",
        "\n",
        "        # optimizer\n",
        "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
        "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
        "\n",
        "        # transition to store in memory\n",
        "        self.transition = list()\n",
        "\n",
        "        # total steps count\n",
        "        self.total_step = 0\n",
        "\n",
        "        # mode: train / test\n",
        "        self.is_test = False\n",
        "\n",
        "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"Select an action from the input state.\"\"\"\n",
        "        # if initial random action should be conducted\n",
        "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
        "            selected_action = self.env.action_space.sample()\n",
        "        else:\n",
        "            selected_action = (\n",
        "                self.actor(torch.FloatTensor(state).to(self.device)).detach().cpu().numpy()\n",
        "            )\n",
        "\n",
        "        # add noise for exploration during training\n",
        "        if not self.is_test:\n",
        "            noise = self.noise.sample()\n",
        "            selected_action = np.clip(selected_action + noise, -1.0, 1.0)\n",
        "\n",
        "        self.transition = [state, selected_action]\n",
        "\n",
        "        return selected_action\n",
        "\n",
        "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
        "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
        "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
        "        done = terminated or truncated\n",
        "\n",
        "        if not self.is_test:\n",
        "            self.transition += [reward, next_state, done]\n",
        "            self.memory.store(*self.transition)\n",
        "\n",
        "        return next_state, reward, done\n",
        "\n",
        "    def update_model(self) -> torch.Tensor:\n",
        "        \"\"\"Update the model by gradient descent.\"\"\"\n",
        "        device = self.device  # for shortening the following lines\n",
        "\n",
        "        # sample from replay buffer\n",
        "        samples = self.memory.sample_batch()\n",
        "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
        "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
        "        action = torch.FloatTensor(samples[\"acts\"]).to(device)\n",
        "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
        "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
        "\n",
        "        # sample from demo buffer\n",
        "        d_samples = self.demo_memory.sample_batch()\n",
        "        d_state = torch.FloatTensor(d_samples[\"obs\"]).to(device)\n",
        "        d_next_state = torch.FloatTensor(d_samples[\"next_obs\"]).to(device)\n",
        "        d_action = torch.FloatTensor(d_samples[\"acts\"]).to(device)\n",
        "        d_reward = torch.FloatTensor(d_samples[\"rews\"].reshape(-1, 1)).to(device)\n",
        "        d_done = torch.FloatTensor(d_samples[\"done\"].reshape(-1, 1)).to(device)\n",
        "\n",
        "        masks = 1 - done\n",
        "        next_action = self.actor_target(next_state)\n",
        "        next_value = self.critic_target(next_state, next_action)\n",
        "        curr_return = reward + self.gamma * next_value * masks\n",
        "        curr_return = curr_return.to(device).detach()\n",
        "\n",
        "        # train critic\n",
        "        values = self.critic(state, action)\n",
        "        critic_loss = F.mse_loss(values, curr_return)\n",
        "\n",
        "        self.critic_optimizer.zero_grad()\n",
        "        critic_loss.backward()\n",
        "        self.critic_optimizer.step()\n",
        "\n",
        "        # train actor\n",
        "        # PG loss\n",
        "        pg_loss = -self.critic(state, self.actor(state)).mean()\n",
        "\n",
        "        # BC loss\n",
        "        pred_action = self.actor(d_state)\n",
        "        qf_mask = torch.gt(\n",
        "            self.critic(d_state, d_action),\n",
        "            self.critic(d_state, pred_action),\n",
        "        ).to(device)\n",
        "        qf_mask = qf_mask.float()\n",
        "        n_qf_mask = int(qf_mask.sum().item())\n",
        "\n",
        "        if n_qf_mask == 0:\n",
        "            bc_loss = torch.zeros((), device=device)\n",
        "        else:\n",
        "            bc_loss = (torch.mul(pred_action, qf_mask) - torch.mul(d_action, qf_mask)).pow(\n",
        "                2\n",
        "            ).sum() / n_qf_mask\n",
        "\n",
        "        actor_loss = self.lambda1 * pg_loss + self.lambda2 * bc_loss\n",
        "\n",
        "        self.actor_optimizer.zero_grad()\n",
        "        actor_loss.backward()\n",
        "        self.actor_optimizer.step()\n",
        "\n",
        "        # target update\n",
        "        self._target_soft_update()\n",
        "\n",
        "        return actor_loss.data, critic_loss.data\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",
        "        actor_losses = []\n",
        "        critic_losses = []\n",
        "        scores = []\n",
        "        score = 0\n",
        "\n",
        "        for self.total_step in range(1, num_frames + 1):\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "\n",
        "            # if episode ends\n",
        "            if done:\n",
        "                state, _ = self.env.reset(seed=self.seed)\n",
        "                scores.append(score)\n",
        "                score = 0\n",
        "\n",
        "            # if training is ready\n",
        "            if len(self.memory) >= self.batch_size and self.total_step > self.initial_random_steps:\n",
        "                actor_loss, critic_loss = self.update_model()\n",
        "                actor_losses.append(actor_loss.cpu().numpy())\n",
        "                critic_losses.append(critic_loss.cpu().numpy())\n",
        "\n",
        "            # plotting\n",
        "            if self.total_step % plotting_interval == 0:\n",
        "                self._plot(\n",
        "                    self.total_step,\n",
        "                    scores,\n",
        "                    actor_losses,\n",
        "                    critic_losses,\n",
        "                )\n",
        "\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 _target_soft_update(self):\n",
        "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
        "        tau = self.tau\n",
        "\n",
        "        for t_param, l_param in zip(self.actor_target.parameters(), self.actor.parameters()):\n",
        "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
        "\n",
        "        for t_param, l_param in zip(self.critic_target.parameters(), self.critic.parameters()):\n",
        "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\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": "ZYNjTOGOgxPL"
      },
      "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": "SGY94asGgxPL"
      },
      "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": "b5836gTOgxPL"
      },
      "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": "q-YYv3B-gxPL"
      },
      "outputs": [],
      "source": [
        "# environment\n",
        "env = gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")\n",
        "env = ActionNormalizer(env)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5o2h7K2JgxPM"
      },
      "source": [
        "## Set random seed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "E7PmpQRLgxPM"
      },
      "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": "LDRZPokZgxPM"
      },
      "source": [
        "## Initialize\n",
        "We make the demonstration using the well-trained agent in advance. (The given demo.pkl is created using *03.DDPG* agent.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "YY6UEKcdgxPM"
      },
      "outputs": [],
      "source": [
        "import pickle\n",
        "\n",
        "# load demo on replay memory\n",
        "demo_path = \"demo.pkl\"\n",
        "with open(demo_path, \"rb\") as f:\n",
        "    demo = pickle.load(f)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gn7ezCCJgxPM",
        "outputId": "7141f3c0-5b37-4a9b-9b3f-3a097b35c99f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "# parameters\n",
        "num_frames = 50000\n",
        "memory_size = 100000\n",
        "batch_size = 1024\n",
        "demo_batch_size = 128\n",
        "ou_noise_theta = 1.0\n",
        "ou_noise_sigma = 0.1\n",
        "initial_random_steps = 10000\n",
        "\n",
        "agent = BCAgent(\n",
        "    env,\n",
        "    memory_size,\n",
        "    batch_size,\n",
        "    demo_batch_size,\n",
        "    ou_noise_theta,\n",
        "    ou_noise_sigma,\n",
        "    demo,\n",
        "    initial_random_steps=initial_random_steps,\n",
        "    seed=seed,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ILk-cZx-gxPM"
      },
      "source": [
        "## Train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 354
        },
        "id": "wjVc3CXFgxPM",
        "outputId": "2a2f2701-f34e-46b6-a4ba-52c814b00fd7"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 3000x500 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "agent.train(num_frames)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DS-EGD84gxPM"
      },
      "source": [
        "## Test\n",
        "Run the trained agent (1 episode)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wEVP2Z7FgxPM",
        "outputId": "d02eb2d9-7ad8-487e-c9ac-56972a5018df"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "score:  -129.3357475336719\n"
          ]
        }
      ],
      "source": [
        "# test\n",
        "video_folder = \"videos/bc\"\n",
        "agent.test(video_folder=video_folder)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LZker-sagxPM"
      },
      "source": [
        "## Render"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "3xU7ZiOFgxPM",
        "outputId": "850bc2ae-7af6-48a1-d0ca-303f12aff7ed"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
              "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
              "        </video>\n",
              "        "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Played: videos/bc/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": "DZReasUygxPM"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "pg-is-all-you-need",
      "language": "python",
      "name": "pg-is-all-you-need"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.9"
    },
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}