{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wqJRBjH3E6BM"
   },
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Yd2ORhTzE6BN",
    "outputId": "ad10181a-a8b4-4867-871c-fb22957f7822"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting gymnasium==1.0.0\n",
      "  Downloading gymnasium-1.0.0-py3-none-any.whl.metadata (9.5 kB)\n",
      "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (1.26.4)\n",
      "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (3.1.0)\n",
      "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium==1.0.0) (4.12.2)\n",
      "Collecting farama-notifications>=0.0.1 (from gymnasium==1.0.0)\n",
      "  Downloading Farama_Notifications-0.0.4-py3-none-any.whl.metadata (558 bytes)\n",
      "Downloading gymnasium-1.0.0-py3-none-any.whl (958 kB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m958.1/958.1 kB\u001b[0m \u001b[31m18.6 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": "aiPALHOME6BO"
   },
   "source": [
    "# 03. DDPG\n",
    "\n",
    "[T. P. Lillicrap et al., \"Continuous control with deep reinforcement learning.\" arXiv preprint arXiv:1509.02971, 2015.](https://arxiv.org/pdf/1509.02971.pdf)\n",
    "\n",
    "Deep Q Network(DQN)([Mnih et al., 2013;2015](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)) algorithm is combined advances in deep learning with reinforcement learning. However, while DQN solves problems with high-dimentional observation spaces, it can only handle discrete and low-dimentional action spaces because of using greedy policy. For learning in high-dimentional and continous action spaces, the authors 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)).\n",
    "\n",
    "### Deterministic policy gradient\n",
    "The DPG algorithm maintains a parameterized actor function $\\mu(s|\\theta^{\\mu})$ which specifies the current policy by deterministically mapping states to a specific action. The critic $Q(s, a)$ is learned using the Bellman equation as in Q-learning. The actor is updated by following the applying the chain rule to the expected return from the start distribution $J$ with respect to the actor parameters.\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\nabla_{\\theta^{\\mu}}J &\\approx E_{s_t\\sim\\rho^\\beta} [\\nabla_{\\theta^{\\mu}} Q(s,a|\\theta^Q)|_{s=s_t, a=\\mu(s_t|\\theta^\\mu)}] \\\\\n",
    "&= E_{s_t\\sim\\rho^\\beta} [\\nabla_{a} Q(s,a|\\theta^Q)|_{s=s_t, a=\\mu(s_t)} \\nabla_{\\theta^{\\mu}} \\mu(s|\\theta^\\mu)|_{s=s_t}]\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "### Replay buffer\n",
    "One challenge when using neural networks for reinforcement learning is that most optimization algorithms assume that **the samples are independently and identically distributed**. When the samples are generated from exploring sequentially in an environment this assumption no longer holds. The authors used a **replay buffer** to address these issues. Transitions were sampled from the environment according to the exploration policy and the tuple $(s_t, a_t, r_t, s_{t+1})$ was stored in the replay buffer. At each timestep the actor and critic are updated by sampling a minibatch uniformly from the buffer. It allows to benefit from learning across a set of **uncorrelated** transitions.\n",
    "\n",
    "### Soft update target network\n",
    "Since the network $(Q(s,a|\\theta^Q)$ being updated is also used in calculating the target value, the Q update is prone to divergence. To avoid this, the authors use **the target network** like DQN, but modified for actor-critic and using **soft target updates**. Target netwokrs is created by copying the actor and critic networks, $Q'(s,a|\\theta^{Q'})$ and $\\mu'(s|\\theta^{\\mu`})$ respectively, that are used for calculating the target values. The weights of these target networks are then updated by having them slowly track the learned networks:\n",
    "\n",
    "$$\n",
    "\\theta' \\leftarrow \\tau \\theta + (1 - \\tau)\\theta' \\ \\ \\ {with} \\ \\tau \\ll 1.\n",
    "$$\n",
    "\n",
    "It greatly improves the stability of learning.\n",
    "\n",
    "### Exploration for continuous action space\n",
    "An advantage of offpolicies algorithms such as DDPG is that we can treat the problem of exploration independently from the learning algorithm. The authors construct an exploration policy $\\mu'$ by adding noise sampled from a noise process $\\mathcal{N}$ to the actor policy\n",
    "\n",
    "$$\n",
    "\\mu'(s_t) = \\mu(s_t|\\theta^{\\mu}_t) + \\mathcal{N}\n",
    "$$\n",
    "\n",
    "$\\mathcal{N}$ can be chosen to suit the environment. The authors used **Ornstein-Uhlenbeck process** to generate temporally correlated exploration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C9ShAm6IE6BO"
   },
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jetjWY9FE6BO"
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZGt1aQ0uE6BP"
   },
   "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",
    "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": null,
   "metadata": {
    "id": "e9PHVLqFE6BQ"
   },
   "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",
    "        \"\"\"Initializate.\"\"\"\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 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": "6NsFDUPCE6BQ"
   },
   "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": null,
   "metadata": {
    "id": "irA2s_dXE6BQ"
   },
   "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__(self, size: int, mu: float = 0.0, theta: float = 0.15, sigma: float = 0.2):\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": "IAwU1Tt-E6BQ"
   },
   "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": null,
   "metadata": {
    "id": "w4eI_qXDE6BQ"
   },
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int, init_w: float = 3e-3):\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": "NIwVzdehE6BQ"
   },
   "source": [
    "## DDPG Agent\n",
    "Here is a summary of DDPGAgent 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",
    "|\\_target_soft_update| soft update from the local model to the target model.|\n",
    "|\\_plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lnjX7OTqE6BQ"
   },
   "outputs": [],
   "source": [
    "class DDPGAgent:\n",
    "    \"\"\"DDPGAgent 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",
    "        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",
    "        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",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        initial_random_steps: int = 1e4,\n",
    "        seed: int = 777,\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.memory = ReplayBuffer(obs_dim, action_dim, memory_size, batch_size)\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",
    "        # 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",
    "        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",
    "        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",
    "\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",
    "        actor_loss = -self.critic(state, self.actor(state)).mean()\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": "tTE3XFc_E6BR"
   },
   "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": "svP9K2t8E6BR"
   },
   "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": "k3OVCATpE6BR"
   },
   "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": "HQsFJT9EE6BR"
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Vm211T56E6BR"
   },
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "4wbTFhG-E6BR"
   },
   "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": "RcGhqtRvE6BS"
   },
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hu6NljqcE6BS",
    "outputId": "204f477f-5104-4378-ea55-8da611212d04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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",
    "agent = DDPGAgent(\n",
    "    env,\n",
    "    memory_size,\n",
    "    batch_size,\n",
    "    ou_noise_theta,\n",
    "    ou_noise_sigma,\n",
    "    initial_random_steps=initial_random_steps,\n",
    "    seed=seed,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YY3sxXv0E6BU"
   },
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 262
    },
    "id": "IsxUDAbFE6BU",
    "outputId": "855c97ed-3fe2-49c2-f791-4310b474fd07"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7B1WXgI7E6BU"
   },
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yzTs7LwtE6BU",
    "outputId": "3cfdd001-acc5-4965-a6e9-9f187bd9c660"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -127.28615625509657\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "video_folder = \"videos/ddpg\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ERvFMAaWE6BU"
   },
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 279
    },
    "id": "w5oiqLeLE6BU",
    "outputId": "3ccd0877-9071-446e-cd60-7cfc9621fd10"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/ddpg/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": "50eSgEfAE6BU"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "pgayn",
   "language": "python",
   "name": "pgayn"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}