{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y6oBIA6Hr1h3"
      },
      "source": [
        "## Configuration for Colab"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xdZa37Lvr1h4",
        "outputId": "df82f15a-b54e-4bfc-8cb9-4d8ee303c8f6"
      },
      "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[31m10.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": "0hcizH3ur1h5"
      },
      "source": [
        "# 06. DDPGfD\n",
        "\n",
        "[M. Vecerik et al., \"Leveraging Demonstrations for Deep Reinforcement Learning on Robotics Problems with Sparse Rewards.\"arXiv preprint arXiv:1707.08817, 2017](https://arxiv.org/pdf/1707.08817.pdf)\n",
        "\n",
        "ReinforcementLearning (RL) offers, in principle, a method to learn such policies from exploration, but the amount of actual exploration required has prohibited its use in real applications. In this paper the authors address this challenge by combining the demonstration and RL paradigms into a single framework which uses demonstrations to guide a deep-RL algorithm.\n",
        "\n",
        "The central contribution of this paper is to show that off-policy replay-memory-based RL (e.g. DDPG) is a natural vehicle for injecting demonstration data into sparse-reward tasks and that it obviates the need for reward-shaping.\n",
        "\n",
        "The algorithms called DDPG from Demonstration (*DDPGfD*) modifies DDPG to take advantage of demonstrations.\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 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",
        "### Prioritized Experience Replay (PER)\n",
        "Prioritized experience replay modifies the agent to sample more important transitions from its replay buffer more frequently.\n",
        "\n",
        "The probability of sampling a particular transition is proportional to its priority,\n",
        "$$\n",
        "P(i) = \\frac{p_i^{\\alpha}}{\\sum_k p_k^{\\alpha}}\n",
        "$$\n",
        ", where $p_i$ the priority of the transition. The priority is commonly to use the magnitude of a transition’s TD error.\n",
        "\n",
        "DDPGfD uses\n",
        "$$\n",
        "p_i = \\delta^{2}_{i} + \\lambda_3 |\\nabla_a Q(s_i, a_i|\\theta^Q)|^2 + \\epsilon + \\epsilon_D,\n",
        "$$\n",
        "- $\\delta_i$ is the last TD error calculated for this transition. The second term represents the loss applied to the actor.\n",
        "- $\\epsilon$ is a small positive constant to ensure all transitions are sampled with some probability.\n",
        "- $\\epsilon_D$ is a positive constant for demonstration transitions to increase their probability of getting sampled.\n",
        "- $\\lambda_3$ is used to weight the contributions.\n",
        "\n",
        "One more. Let's recall one of the main ideas of DQN. To remove correlation of observations, it uses uniformly random sampling from the replay buffer. Prioritized replay introduces bias because it doesn't sample experiences uniformly at random due to the sampling proportion correspoding to TD-error. We can correct this bias by using importance-sampling (IS) weights\n",
        "\n",
        "$$\n",
        "w_i = \\big( \\frac{1}{N} \\cdot \\frac{1}{P(i)} \\big)^\\beta\n",
        "$$\n",
        "\n",
        "that fully compensates for the non-uniform probabilities $P(i)$ if $\\beta = 1$. These weights can be folded into the Q-learning update by using $w_i\\delta_i$ instead of $\\delta_i$.\n",
        "\n",
        "For details, refer to the PER paper ([T. Schaul et al., 2015.](https://arxiv.org/pdf/1511.05952.pdf))\n",
        "\n",
        "### A mix of 1-step and n-step returns\n",
        "A modification for the sparse reward case is to use a mix of 1-step and n-step returns when updating the critic function. Incorporating *n-step returns* helps propagate the Q-values along the trajectories.\n",
        "\n",
        "The n-step return has the following form:\n",
        "$$\n",
        "R_n = \\sum^{n-1}_{i=0} \\gamma^i r_i + \\gamma^n Q(s'_{n-1}, \\pi(s'_{n-1}; \\theta^{Q'}))\n",
        "$$\n",
        "\n",
        "The loss corresponding to this particular rollout is then:\n",
        "$$\n",
        "L_n(\\theta^Q) = \\frac{1}{2} (R_n - Q(s, \\pi(s) | \\theta^Q))^2\n",
        "$$\n",
        "\n",
        "### Loss function\n",
        "The loss function is combined the above mentioned losses. Additionally *L2 regularization* on the parameters of the actor and the critic networks are added to stabilize the final learning performance. Two parameters called $\\lambda_1$, $\\lambda_2$ are used to weight the contributions.\n",
        "\n",
        "$$\n",
        "L_{Critic}(\\theta ^ Q) = L_1(\\theta^Q) + \\lambda_1 L_n(\\theta^Q) + \\lambda_2 L^{C}_{reg} (\\theta^Q)   \\\\\n",
        "$$\n",
        "$$\n",
        "\\nabla_{\\theta^{\\pi}} L_{Actor}(\\theta^\\pi) = - \\nabla_{\\theta^{\\pi}} J(\\theta^\\pi) + \\lambda_2 L^{A}_{reg} (\\theta^\\pi)\n",
        "$$\n",
        "\n",
        "### Pretrain\n",
        "We make use of the demonstration data to pre-train the agent so that it can perform well in the task from the start of learning, and then continue improving from its own self-generated data.\n",
        "\n",
        "Reference:\n",
        "- [Pseudo code of DDPGfD paper](https://arxiv.org/pdf/1707.08817.pdf)\n",
        "- [DQfD](https://arxiv.org/pdf/1704.03732)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rc5UvAjzr1h5"
      },
      "source": [
        "## Import modules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kHWoaeHar1h6",
        "outputId": "2f224165-7fdb-4a46-ab5c-760157db25d1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-12-30 03:50:47--  https://raw.githubusercontent.com/mrsyee/pg-is-all-you-need/master/segment_tree.py\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.110.133, 185.199.109.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 4268 (4.2K) [text/plain]\n",
            "Saving to: ‘segment_tree.py’\n",
            "\n",
            "segment_tree.py     100%[===================>]   4.17K  --.-KB/s    in 0s      \n",
            "\n",
            "2024-12-30 03:50:48 (45.6 MB/s) - ‘segment_tree.py’ saved [4268/4268]\n",
            "\n",
            "--2024-12-30 03:50:48--  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.111.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",
            "demo.pkl            100%[===================>] 175.58K  --.-KB/s    in 0.03s   \n",
            "\n",
            "2024-12-30 03:50:48 (5.22 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(\"segment_tree.py\") and not os.path.exists(\"demo.pkl\"):\n",
        "    # download segment tree module\n",
        "    !wget https://raw.githubusercontent.com/mrsyee/pg-is-all-you-need/master/segment_tree.py\n",
        "    # download demo.pkl\n",
        "    !wget https://raw.githubusercontent.com/mrsyee/pg-is-all-you-need/master/demo.pkl\n",
        "\n",
        "from segment_tree import MinSegmentTree, SumSegmentTree"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DniDkOjAr1h6"
      },
      "source": [
        "## Replay buffer for N-step learning with demonstration\n",
        "\n",
        "There are a little bit changes in Replay buffer for N-step learning with demonstration.\n",
        "\n",
        "First, we use `deque` to store the most recent n-step transitions.\n",
        "\n",
        "```python\n",
        "    self.n_step_buffer = deque(maxlen=n_step)\n",
        "```\n",
        "\n",
        "You can see it doesn't actually store a transition in the buffer, unless `n_step_buffer` is full.\n",
        "\n",
        "```\n",
        "    # in store method\n",
        "    if len(self.n_step_buffer) < self.n_step:\n",
        "        return ()\n",
        "```\n",
        "\n",
        "When the length of `n_step_buffer` becomes equal to N, it eventually stores the N-step transition, which is calculated by `get_n_step_info` method (reference `util.py`). Furthermore, there are additional implementations for saving loaded demos. (Please see *03.DDPG.ipynb* for detailed description of the basic replay buffer.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "DDqywOz3r1h6"
      },
      "outputs": [],
      "source": [
        "class ReplayBuffer:\n",
        "    \"\"\"A numpy replay buffer with demonstrations.\"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        obs_dim: int,\n",
        "        act_dim: int,\n",
        "        size: int,\n",
        "        batch_size: int = 32,\n",
        "        gamma: float = 0.99,\n",
        "        demo: list = None,\n",
        "        n_step: int = 1,\n",
        "    ):\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",
        "        # for N-step Learning\n",
        "        self.n_step_buffer = deque(maxlen=n_step)\n",
        "        self.n_step = n_step\n",
        "        self.gamma = gamma\n",
        "\n",
        "        # for demonstration\n",
        "        self.demo_size = len(demo) if demo else 0\n",
        "        self.demo = demo\n",
        "\n",
        "        if self.demo:\n",
        "            self.ptr += self.demo_size\n",
        "            self.size += self.demo_size\n",
        "            for ptr, d in enumerate(self.demo):\n",
        "                state, action, reward, next_state, done = d\n",
        "                self.obs_buf[ptr] = state\n",
        "                self.acts_buf[ptr] = np.array(action)\n",
        "                self.rews_buf[ptr] = reward\n",
        "                self.next_obs_buf[ptr] = next_state\n",
        "                self.done_buf[ptr] = done\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",
        "    ) -> Tuple[np.ndarray, np.ndarray, float, np.ndarray, bool]:\n",
        "        \"\"\"Store the transition in buffer.\"\"\"\n",
        "        transition = (obs, act, rew, next_obs, done)\n",
        "        self.n_step_buffer.append(transition)\n",
        "\n",
        "        # single step transition is not ready\n",
        "        if len(self.n_step_buffer) < self.n_step:\n",
        "            return ()\n",
        "\n",
        "        # make a n-step transition\n",
        "        rew, next_obs, done = self._get_n_step_info()\n",
        "        obs, act = self.n_step_buffer[0][:2]\n",
        "\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",
        "\n",
        "        self.ptr += 1\n",
        "        self.ptr = self.demo_size if self.ptr % self.max_size == 0 else self.ptr\n",
        "        self.size = min(self.size + 1, self.max_size)\n",
        "\n",
        "        return self.n_step_buffer[0]\n",
        "\n",
        "    def sample_batch(self, indices: List[int] = None) -> Dict[str, np.ndarray]:\n",
        "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
        "        assert len(self) >= self.batch_size\n",
        "\n",
        "        if indices is None:\n",
        "            indices = np.random.choice(len(self), size=self.batch_size, replace=False)\n",
        "\n",
        "        return dict(\n",
        "            obs=self.obs_buf[indices],\n",
        "            next_obs=self.next_obs_buf[indices],\n",
        "            acts=self.acts_buf[indices],\n",
        "            rews=self.rews_buf[indices],\n",
        "            done=self.done_buf[indices],\n",
        "            # for N-step learning\n",
        "            indices=indices,\n",
        "        )\n",
        "\n",
        "    def _get_n_step_info(self) -> Tuple[np.int64, np.ndarray, bool]:\n",
        "        \"\"\"Return n step rew, next_obs, and done.\"\"\"\n",
        "        # info of the last transition\n",
        "        rew, next_obs, done = self.n_step_buffer[-1][-3:]\n",
        "\n",
        "        for transition in reversed(list(self.n_step_buffer)[:-1]):\n",
        "            r, n_o, d = transition[-3:]\n",
        "\n",
        "            rew = r + self.gamma * rew * (1 - d)\n",
        "            next_obs, done = (n_o, d) if d else (next_obs, done)\n",
        "\n",
        "        return rew, next_obs, done\n",
        "\n",
        "    def __len__(self) -> int:\n",
        "        return self.size"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "of_4-aMGr1h6"
      },
      "source": [
        "## Prioritized replay Buffer with demonstration\n",
        "\n",
        "The key concept of PER's implementation is *Segment Tree*. It efficiently stores and samples transitions while managing the priorities of them (reference `segment_tree.py`). We recommend you understand how it works before you move on. Here are references for you:\n",
        "\n",
        "- In Korean: https://mrsyee.github.io/rl/2019/01/25/PER-sumtree/\n",
        "- In English: https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/\n",
        "\n",
        "In addtion, `epsilon_d` is a positive constant for demonstration transitions to increase their probability of getting sampled."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "gkh9KF68r1h6"
      },
      "outputs": [],
      "source": [
        "class PrioritizedReplayBuffer(ReplayBuffer):\n",
        "    \"\"\"Prioritized Replay buffer with demonstrations.\"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        obs_dim: int,\n",
        "        act_dim: int,\n",
        "        size: int,\n",
        "        batch_size: int = 32,\n",
        "        gamma: float = 0.99,\n",
        "        alpha: float = 0.6,\n",
        "        epsilon_d: float = 1.0,\n",
        "        demo: list = None,\n",
        "    ):\n",
        "        \"\"\"Initialize.\"\"\"\n",
        "        assert alpha >= 0\n",
        "\n",
        "        super(PrioritizedReplayBuffer, self).__init__(\n",
        "            obs_dim, act_dim, size, batch_size, gamma, demo, n_step=1\n",
        "        )\n",
        "        self.max_priority, self.tree_ptr = 1.0, 0\n",
        "        self.alpha = alpha\n",
        "        self.epsilon_d = epsilon_d\n",
        "\n",
        "        # capacity must be positive and a power of 2.\n",
        "        tree_capacity = 1\n",
        "        while tree_capacity < self.max_size:\n",
        "            tree_capacity *= 2\n",
        "\n",
        "        self.sum_tree = SumSegmentTree(tree_capacity)\n",
        "        self.min_tree = MinSegmentTree(tree_capacity)\n",
        "\n",
        "        # for init priority of demo\n",
        "        self.tree_ptr = self.demo_size\n",
        "        for i in range(self.demo_size):\n",
        "            self.sum_tree[i] = self.max_priority**self.alpha\n",
        "            self.min_tree[i] = self.max_priority**self.alpha\n",
        "\n",
        "    def store(self, obs: np.ndarray, act: int, rew: float, next_obs: np.ndarray, done: bool):\n",
        "        \"\"\"Store experience and priority.\"\"\"\n",
        "        transition = super().store(obs, act, rew, next_obs, done)\n",
        "\n",
        "        if transition:\n",
        "            self.sum_tree[self.tree_ptr] = self.max_priority**self.alpha\n",
        "            self.min_tree[self.tree_ptr] = self.max_priority**self.alpha\n",
        "\n",
        "            self.tree_ptr += 1\n",
        "            if self.tree_ptr % self.max_size == 0:\n",
        "                self.tree_ptr = self.demo_size\n",
        "\n",
        "        return transition\n",
        "\n",
        "    def sample_batch(self, beta: float = 0.4) -> Dict[str, np.ndarray]:\n",
        "        \"\"\"Sample a batch of experiences.\"\"\"\n",
        "        assert len(self) >= self.batch_size\n",
        "        assert beta > 0\n",
        "\n",
        "        indices = self._sample_proportional()\n",
        "\n",
        "        obs = self.obs_buf[indices]\n",
        "        next_obs = self.next_obs_buf[indices]\n",
        "        acts = self.acts_buf[indices]\n",
        "        rews = self.rews_buf[indices]\n",
        "        done = self.done_buf[indices]\n",
        "        weights = np.array([self._calculate_weight(i, beta) for i in indices])\n",
        "        epsilon_d = np.array([self.epsilon_d if i < self.demo_size else 0.0 for i in indices])\n",
        "\n",
        "        return dict(\n",
        "            obs=obs,\n",
        "            next_obs=next_obs,\n",
        "            acts=acts,\n",
        "            rews=rews,\n",
        "            done=done,\n",
        "            weights=weights,\n",
        "            epsilon_d=epsilon_d,\n",
        "            indices=indices,\n",
        "        )\n",
        "\n",
        "    def update_priorities(self, indices: List[int], priorities: np.ndarray):\n",
        "        \"\"\"Update priorities of sampled transitions.\"\"\"\n",
        "        assert len(indices) == len(priorities)\n",
        "\n",
        "        for idx, priority in zip(indices, priorities):\n",
        "            assert priority > 0\n",
        "            assert 0 <= idx < len(self)\n",
        "\n",
        "            self.sum_tree[idx] = priority**self.alpha\n",
        "            self.min_tree[idx] = priority**self.alpha\n",
        "\n",
        "            self.max_priority = max(self.max_priority, priority)\n",
        "\n",
        "    def _sample_proportional(self) -> List[int]:\n",
        "        \"\"\"Sample indices based on proportions.\"\"\"\n",
        "        indices = []\n",
        "        p_total = self.sum_tree.sum(0, len(self) - 1)\n",
        "        segment = p_total / self.batch_size\n",
        "\n",
        "        for i in range(self.batch_size):\n",
        "            a = segment * i\n",
        "            b = segment * (i + 1)\n",
        "            upperbound = random.uniform(a, b)\n",
        "            idx = self.sum_tree.retrieve(upperbound)\n",
        "            indices.append(idx)\n",
        "\n",
        "        return indices\n",
        "\n",
        "    def _calculate_weight(self, idx: int, beta: float):\n",
        "        \"\"\"Calculate the weight of the experience at idx.\"\"\"\n",
        "        # get max weight\n",
        "        p_min = self.min_tree.min() / self.sum_tree.sum()\n",
        "        max_weight = (p_min * len(self)) ** (-beta)\n",
        "\n",
        "        # calculate weights\n",
        "        p_sample = self.sum_tree[idx] / self.sum_tree.sum()\n",
        "        weight = (p_sample * len(self)) ** (-beta)\n",
        "        weight = weight / max_weight\n",
        "\n",
        "        return weight"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LiwEFo4jr1h7"
      },
      "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": 42,
      "metadata": {
        "id": "91S4Gu3ur1h7"
      },
      "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": "huJKTFKIr1h7"
      },
      "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": 43,
      "metadata": {
        "id": "7Wa67dv8r1h7"
      },
      "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": "3PpQHfF8r1h7"
      },
      "source": [
        "## DDPGfD Agent\n",
        "Here is a summary of DDPGfDAgent 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",
        "|\\_pretrain        |pretraining steps.|\n",
        "|\\_get_critic_loss   | return element-wise critic loss.                     |\n",
        "|\\_target_soft_update| soft update from the local model to the target model.|\n",
        "|\\_get_n_step_info_from_demo | return 1 step and n step demos. |"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "id": "dmf3GKBur1h7"
      },
      "outputs": [],
      "source": [
        "class DDPGfDAgent:\n",
        "    \"\"\"DDPGfDAgent 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",
        "        demo (list): demonstration\n",
        "        memory (ReplayBuffer): replay memory to store transitions\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",
        "        pretrain_step (int): the number of step for pre-training\n",
        "        n_step (int): the number of multi step\n",
        "        use_n_step (bool): whether to use n_step memory\n",
        "        prior_eps (float): guarantees every transitions can be sampled\n",
        "        lambda1 (float): n-step return weight\n",
        "        lambda2 (float): l2 regularization weight\n",
        "        lambda3 (float): actor loss contribution of prior weight\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",
        "        ou_noise_theta: float,\n",
        "        ou_noise_sigma: float,\n",
        "        demo: list,\n",
        "        pretrain_step: int,\n",
        "        gamma: float = 0.99,\n",
        "        tau: float = 5e-3,\n",
        "        initial_random_steps: int = 1e4,\n",
        "        seed: int = 777,\n",
        "        # PER parameters\n",
        "        alpha: float = 0.3,\n",
        "        beta: float = 1.0,\n",
        "        prior_eps: float = 1e-6,\n",
        "        # N-step Learning\n",
        "        n_step: int = 3,\n",
        "        # loss parameters\n",
        "        lambda1: float = 1.0,  # N-step return weight\n",
        "        lambda2: float = 1e-4,  # l2 regularization weight\n",
        "        lambda3: float = 1.0,  # actor loss contribution of prior weight\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.pretrain_step = pretrain_step\n",
        "        self.gamma = gamma\n",
        "        self.tau = tau\n",
        "        self.initial_random_steps = initial_random_steps\n",
        "        self.seed = seed\n",
        "        self.lambda1 = lambda1\n",
        "        self.lambda3 = lambda3\n",
        "\n",
        "        self.demo = demo\n",
        "        demos_1_step, demos_n_step = [], []\n",
        "        if self.demo:\n",
        "            demos_1_step, demos_n_step = self._get_n_step_info_from_demo(demo, n_step)\n",
        "\n",
        "        # PER\n",
        "        # memory for 1-step Learning\n",
        "        self.beta = beta\n",
        "        self.prior_eps = prior_eps\n",
        "        self.memory = PrioritizedReplayBuffer(\n",
        "            obs_dim, action_dim, memory_size, batch_size, gamma, alpha, demo=demos_1_step\n",
        "        )\n",
        "\n",
        "        # memory for N-step Learning\n",
        "        self.use_n_step = True if n_step > 1 else False\n",
        "        if self.use_n_step:\n",
        "            self.n_step = n_step\n",
        "            self.memory_n = ReplayBuffer(\n",
        "                obs_dim, action_dim, memory_size, batch_size, gamma, demos_n_step, self.n_step\n",
        "            )\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(\n",
        "            self.actor.parameters(),\n",
        "            lr=3e-4,\n",
        "            weight_decay=lambda2,\n",
        "        )\n",
        "        self.critic_optimizer = optim.Adam(\n",
        "            self.critic.parameters(),\n",
        "            lr=1e-3,\n",
        "            weight_decay=lambda2,\n",
        "        )\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",
        "\n",
        "            # N-step transition\n",
        "            transition = self.transition\n",
        "            if self.use_n_step:\n",
        "                transition = self.memory_n.store(*self.transition)\n",
        "\n",
        "            # add a single step transition\n",
        "            if transition:\n",
        "                self.memory.store(*transition)\n",
        "\n",
        "        return next_state, reward, done\n",
        "\n",
        "    def update_model(self) -> Tuple[torch.Tensor, ...]:\n",
        "        \"\"\"Update the model by gradient descent.\"\"\"\n",
        "        device = self.device  # for shortening the following lines\n",
        "\n",
        "        samples = self.memory.sample_batch(self.beta)\n",
        "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
        "        action = torch.FloatTensor(samples[\"acts\"]).to(device)\n",
        "\n",
        "        weights = torch.FloatTensor(samples[\"weights\"].reshape(-1, 1)).to(device)\n",
        "        epsilon_d = samples[\"epsilon_d\"]\n",
        "        indices = samples[\"indices\"]\n",
        "\n",
        "        # train critic\n",
        "        # 1-step loss\n",
        "        critic_loss_element_wise = self._get_critic_loss(samples, self.gamma)\n",
        "        critic_loss = torch.mean(critic_loss_element_wise * weights)\n",
        "\n",
        "        # n-step loss\n",
        "        if self.use_n_step:\n",
        "            samples_n = self.memory_n.sample_batch(indices)\n",
        "            n_gamma = self.gamma**self.n_step\n",
        "            critic_loss_n_element_wise = self._get_critic_loss(samples_n, n_gamma)\n",
        "\n",
        "            # to update loss and priorities\n",
        "            critic_loss_element_wise += critic_loss_n_element_wise * self.lambda1\n",
        "            critic_loss = torch.mean(critic_loss_element_wise * weights)\n",
        "\n",
        "        self.critic_optimizer.zero_grad()\n",
        "        critic_loss.backward()\n",
        "        self.critic_optimizer.step()\n",
        "\n",
        "        # train actor\n",
        "        actor_loss_element_wise = -self.critic(state, self.actor(state))\n",
        "        actor_loss = torch.mean(actor_loss_element_wise * weights)\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",
        "        # PER: update priorities\n",
        "        new_priorities = critic_loss_element_wise\n",
        "        new_priorities += self.lambda3 * actor_loss_element_wise.pow(2)\n",
        "        new_priorities += self.prior_eps\n",
        "        new_priorities = new_priorities.data.cpu().numpy().squeeze()\n",
        "        new_priorities += epsilon_d\n",
        "        self.memory.update_priorities(indices, new_priorities)\n",
        "\n",
        "        # check the number of sampling demos\n",
        "        demo_idxs = np.where(epsilon_d != 0.0)\n",
        "        n_demo = demo_idxs[0].size\n",
        "\n",
        "        return actor_loss.data, critic_loss.data, n_demo\n",
        "\n",
        "    def _pretrain(self) -> Tuple[List[torch.Tensor], List[torch.Tensor]]:\n",
        "        \"\"\"Pretraining steps.\"\"\"\n",
        "        actor_losses = []\n",
        "        critic_losses = []\n",
        "        print(\"Pre-Train %d step.\" % self.pretrain_step)\n",
        "        for _ in range(1, self.pretrain_step + 1):\n",
        "            actor_loss, critic_loss, _ = self.update_model()\n",
        "            actor_losses.append(actor_loss.data.cpu().numpy())\n",
        "            critic_losses.append(critic_loss.data.cpu().numpy())\n",
        "        print(\"Pre-Train Complete!\\n\")\n",
        "        return actor_losses, critic_losses\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, critic_losses, n_demo_list, scores = [], [], [], []\n",
        "        score = 0\n",
        "\n",
        "        if self.demo:\n",
        "            output = self._pretrain()\n",
        "            actor_losses.extend(output[0])\n",
        "            critic_losses.extend(output[1])\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",
        "            # PER: increase beta\n",
        "            fraction = min(self.total_step / num_frames, 1.0)\n",
        "            self.beta = self.beta + fraction * (1.0 - self.beta)\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, n_demo = self.update_model()\n",
        "                actor_losses.append(actor_loss.cpu().numpy())\n",
        "                critic_losses.append(critic_loss.cpu().numpy())\n",
        "                n_demo_list.append(n_demo)\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_demo_list,\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 _get_critic_loss(self, samples: Dict[str, np.ndarray], gamma: float) -> torch.Tensor:\n",
        "        \"\"\"Return element-wise critic loss.\"\"\"\n",
        "        device = self.device  # for shortening the following lines\n",
        "\n",
        "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
        "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
        "        action = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).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",
        "        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 + 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_element_wise = (values - curr_return).pow(2)\n",
        "\n",
        "        return critic_loss_element_wise\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 _get_n_step_info_from_demo(self, demo: List, n_step: int) -> Tuple[List, List]:\n",
        "        \"\"\"Return 1 step and n step demos.\"\"\"\n",
        "        demos_1_step = list()\n",
        "        demos_n_step = list()\n",
        "        n_step_buffer: Deque = deque(maxlen=n_step)\n",
        "\n",
        "        for transition in demo:\n",
        "            n_step_buffer.append(transition)\n",
        "\n",
        "            if len(n_step_buffer) == n_step:\n",
        "                # add a single step transition\n",
        "                demos_1_step.append(n_step_buffer[0])\n",
        "\n",
        "                # add a multi step transition\n",
        "                curr_state, action = n_step_buffer[0][:2]\n",
        "\n",
        "                # get n-step info\n",
        "                reward, next_state, done = n_step_buffer[-1][-3:]\n",
        "                for transition in reversed(list(n_step_buffer)[:-1]):\n",
        "                    r, n_o, d = transition[-3:]\n",
        "\n",
        "                    reward = r + self.gamma * reward * (1 - d)\n",
        "                    next_state, done = (n_o, d) if d else (next_state, done)\n",
        "\n",
        "                transition = (curr_state, action, reward, next_state, done)\n",
        "                demos_n_step.append(transition)\n",
        "\n",
        "        return demos_1_step, demos_n_step\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_demo: List[int],\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",
        "            (141, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
        "            (142, \"actor_loss\", actor_losses),\n",
        "            (143, \"critic_loss\", critic_losses),\n",
        "            (144, \"the number of sampling demos\", n_demo),\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": "xMqMNkajr1h8"
      },
      "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": 45,
      "metadata": {
        "id": "NOdDWxJ3r1h8"
      },
      "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": "SmUmwNENr1h8"
      },
      "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": 46,
      "metadata": {
        "id": "ntjiX-DSr1h8"
      },
      "outputs": [],
      "source": [
        "# environment\n",
        "env = gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")\n",
        "env = ActionNormalizer(env)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ljBP43yLr1h9"
      },
      "source": [
        "## Set random seed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "xjRhxcq7r1h9"
      },
      "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": "WQRLfiqir1h9"
      },
      "source": [
        "## Initialize\n",
        "We make the demonstration using the well-trained agent in advance. (The given demo.pkl is created transitions using *03.DDPG* agent.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "cvo5ao37r1h9"
      },
      "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": 55,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5qqCMnycr1h9",
        "outputId": "0dcc5341-08d9-4718-de62-09c21a62db5a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "# parameters\n",
        "num_frames = 50000\n",
        "memory_size = 100000\n",
        "batch_size = 128\n",
        "ou_noise_theta = 1.0\n",
        "ou_noise_sigma = 0.1\n",
        "initial_random_steps = 10000\n",
        "n_step = 3\n",
        "pretrain_step = 1000\n",
        "\n",
        "agent = DDPGfDAgent(\n",
        "    env,\n",
        "    memory_size,\n",
        "    batch_size,\n",
        "    ou_noise_theta,\n",
        "    ou_noise_sigma,\n",
        "    demo=demo,\n",
        "    n_step=n_step,\n",
        "    pretrain_step=pretrain_step,\n",
        "    initial_random_steps=initial_random_steps,\n",
        "    seed=seed,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KjP9Q_x3r1h9"
      },
      "source": [
        "## Train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 354
        },
        "id": "5ooFU6lbr1h9",
        "outputId": "f2fb5b08-60dc-4c6b-ba1b-b72df7f1359e"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 3000x500 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "agent.train(num_frames)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9BXZvX4yr1h9"
      },
      "source": [
        "## Test\n",
        "Run the trained agent (1 episode)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E5HQS07sr1h9",
        "outputId": "1d288124-456e-4659-bfbd-f62b7933682e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "score:  -126.30216798524621\n"
          ]
        }
      ],
      "source": [
        "# test\n",
        "video_folder = \"videos/ddpgfd\"\n",
        "agent.test(video_folder=video_folder)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FwsCqXj0r1h9"
      },
      "source": [
        "## Render"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "EIHEsAnTr1h9",
        "outputId": "da004988-e2e9-429d-ed9c-b98b7979ef27"
      },
      "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/ddpgfd/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": "qP75O281r1h-"
      },
      "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
}