Pendulum_Replay_Experince.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Continuous Pendulum with function appoximation and control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Notebook is intended to solve the Continuous Pendulum problem using Policy gradient methods (Deep actor-critic) with experience replay.\n",
    "\n",
    "The description of the problem is given below:\n",
    "\n",
    "\"The inverted pendulum swingup problem is a classic problem in the control literature. In this version of the problem, the pendulum starts in a random position, and the goal is to swing it up so it stays upright..\" \n",
    "\n",
    "<img src=\"./assets/pendulum.png\" width=\"380\" />\n",
    "\n",
    "Image and eext taken from [Official documentaiton Pendulum](https://gym.openai.com/envs/Pendulum-v0/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "\n",
    "from copy import deepcopy\n",
    "import gym\n",
    "from gym.wrappers import Monitor\n",
    "from utils import *\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "from torch import optim\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markov Decision Process\n",
    "\n",
    "As a quick recap, the diagram below explains the workflow of a Markov Decision Process (MDP)\n",
    "\n",
    "<img src=\"./assets/MDP.png\" width=\"380\" />\n",
    "\n",
    "Image taken from [Section 3.1 Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=70)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment and Agent specifications\n",
    "\n",
    "The states, actions, reward and termination are given as follows for the lunar lander problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observation**: \n",
    "\n",
    "     Type:  Box(2)\n",
    "     Num \tObservation \t Min \tMax\n",
    "     0 \t  cos(theta)      -1.0 \t1.0\n",
    "     1 \t  sin(theta) \t -1.0 \t1.0\n",
    "     2       theta dot \t  -8.0 \t8.0\n",
    "         \n",
    "**Actions**:\n",
    "\n",
    "     Type: Box(1)\n",
    "     Num \tAction \t        Min \tMax\n",
    "     0 \t  Joint effort      -2.0 \t2.0\n",
    "\n",
    "        \n",
    "**Reward**:\n",
    "\n",
    "     -(theta^2 + 0.1*theta_dt^2 + 0.001*action^2)\n",
    "\n",
    "        \n",
    "**Starting State**:\n",
    "\n",
    "     Random angle from -pi to pi, and random velocity between -1 and 1\n",
    "        \n",
    "**Episode Termination**:\n",
    "\n",
    "     Continuous problem\n",
    "     \n",
    "For further information see [Github source code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next cell aims to show how to iterate with the action and observation space of the agent and extract relevant information from it "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Action Space is an object of type: Box(1,)\n",
      "\n",
      "The shape of the action space is: (1,)\n",
      "\n",
      "The High values in the action space are [2.], the low values are [-2.]\n",
      "\n",
      "The Environment Space is an object of type: Box(3,)\n",
      "\n",
      "The Shape of the dimension Space are: (3,)\n",
      "\n",
      "The High values in the observation space are [1. 1. 8.], the low values are [-1. -1. -8.]\n",
      "\n",
      "The Observations at a given timestep are [ 0.57545656 -0.8486819   2.7881505 ]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"Pendulum-v0\")\n",
    "observation = env.reset() \n",
    "\n",
    "# Object's type in the action Space\n",
    "print(\"The Action Space is an object of type: {0}\\n\".format(env.action_space))\n",
    "# Shape of the action Space\n",
    "print(\"The shape of the action space is: {0}\\n\".format(env.action_space.shape))\n",
    "# The high and low values in the action space\n",
    "print(\"The High values in the action space are {0}, the low values are {1}\\n\".format(\n",
    "    env.action_space.high, env.action_space.low))\n",
    "# Object's type in the Observation Space\n",
    "print(\"The Environment Space is an object of type: {0}\\n\".format(env.observation_space))\n",
    "# Shape of the observation space\n",
    "print(\"The Shape of the dimension Space are: {0}\\n\".format(env.observation_space.shape))\n",
    "# The high and low values in the observation space\n",
    "print(\"The High values in the observation space are {0}, the low values are {1}\\n\".format(\n",
    "    env.observation_space.high, env.observation_space.low))\n",
    "# Example of observation\n",
    "print(\"The Observations at a given timestep are {0}\\n\".format(env.observation_space.sample()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Critic Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this problem, the critic is a Neural Network with a single output. The input dimension is equal to the number of states in the problem. Recall that.\n",
    "\n",
    "$$ v_\\pi(s) \\approx \\hat{v}(s, w) = NN(s, w) $$\n",
    "\n",
    "<img src=\"./assets/nn_2.png\" width=\"340\" />\n",
    "\n",
    "For further information about Neural Networks for function approximation see [Section 9.7 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=246). **Note**: Image taken from the last reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Critic Neural Network\n",
    "class Critic(nn.Module):\n",
    "    # Work Required: Yes. Fill in the layer_sizes member variable (~1 Line).\n",
    "    def __init__(self, critic_config):\n",
    "        super().__init__()\n",
    "        \n",
    "        # Number of states\n",
    "        self.state_dim = critic_config.get(\"state_dim\")\n",
    "        # Hidden units\n",
    "        self.num_hidden_units = critic_config.get(\"num_hidden_units\")\n",
    "        \n",
    "        # Initialzie first hidden layer \n",
    "        self.hidden_1 = nn.Linear(self.state_dim, self.num_hidden_units)\n",
    "        # Initialzie second hidden layer \n",
    "        self.hidden_2 = nn.Linear(self.num_hidden_units, self.num_hidden_units)\n",
    "        # Initialize output layer\n",
    "        self.output = nn.Linear(self.num_hidden_units, 1)\n",
    "                                \n",
    "    \n",
    "    def forward(self, s):\n",
    "        \"\"\"\n",
    "        This is a feed-forward pass in the network\n",
    "        Args:\n",
    "            s (Numpy array): The state, a 2D array of shape (state_dim)\n",
    "        Returns:\n",
    "            The value estimates (Torch array) calculated using the network's weights.\n",
    "            A 2D array of shape (num_actions)\n",
    "        \"\"\"\n",
    "        # Transform observations into a pytorch tensor\n",
    "        s = torch.Tensor(s)\n",
    "        \n",
    "        v = F.relu(self.hidden_1(s))\n",
    "        v = F.relu(self.hidden_2(v))\n",
    "        v = self.output(v)\n",
    "\n",
    "        return v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Actor Neural Network\n",
    "\n",
    "As this is a contininuous problem, it is possible to use a Normal distribution to sample actions. For this task, a neural network is used to compute $\\mu$ which is the mean. The value of $\\sigma$ or standard deviation is updated by the backprop algorithm, nevertheless, it is set to a fixed value from the beginning. The NN is not used to compute $\\sigma$ as different tests showed that computing both values make the experiment quite unstable.\n",
    "\n",
    "$$ \\pi(a | s, \\theta) \\doteq \\frac{1}{\\sigma(s, \\theta) \\sqrt{2\\pi}}e^-{\\frac{(a-\\mu(s,\\theta))^2}{2\\sigma(s,\\theta)^2}} $$\n",
    "\n",
    "As $\\mu$ is computed by the network, $\\mu$ and $\\sigma$ are automatically adjusted depending on the current state of the problem. The input of the neural netork are the states of the problem, the output is composed of one output node ($\\mu$) owing to the unique action in this problem.\n",
    "\n",
    "For further explanation see [Section 13.7 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=357)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Actor neural network\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self,  actor_config):\n",
    "        super().__init__()\n",
    "                \n",
    "        # Number of states\n",
    "        self.state_dim = actor_config.get(\"state_dim\")\n",
    "        # Hidden units\n",
    "        self.num_hidden_units = actor_config.get(\"num_hidden_units\")\n",
    "        # Actions or output units\n",
    "        self.num_actions = actor_config.get(\"num_actions\")\n",
    "        \n",
    "        # Initialzie first hidden layer \n",
    "        self.hidden_1 = nn.Linear(self.state_dim, self.num_hidden_units)\n",
    "        # Initialzie second hidden layer \n",
    "        self.hidden_2 = nn.Linear(self.num_hidden_units, self.num_hidden_units)\n",
    "        # Initialize output layer (muliply output by 2 to obtain mu and sigma)\n",
    "        self.output = nn.Linear(self.num_hidden_units, self.num_actions)\n",
    "        \n",
    "        # Log of standard deviation\n",
    "        logstdv_param = nn.Parameter(torch.full((self.num_actions,), 0.1))\n",
    "        # Register parameter in the network\n",
    "        self.register_parameter(\"logstdv\", logstdv_param)\n",
    "                        \n",
    "    def compute_mean(self, s):\n",
    "        \"\"\"\n",
    "        This is a feed-forward pass in the network\n",
    "        Args:\n",
    "            s (Numpy array): The state, a 2D array of shape (state_dim)\n",
    "        Returns:\n",
    "            Mean and stdv (Torch array) calculated using the network's weights.\n",
    "            A 2D array of shape (num_actions * 2)\n",
    "        \"\"\"\n",
    "        # Transform observations into a pytorch tensor\n",
    "        s = torch.Tensor(s)\n",
    "        \n",
    "        pi = F.relu(self.hidden_1(s))\n",
    "        pi = F.relu(self.hidden_2(pi))\n",
    "        pi = self.output(pi)\n",
    "        \n",
    "        return pi\n",
    "                \n",
    "    \n",
    "    def forward(self, s):\n",
    "        \n",
    "        # Compute the mean and log stedv with the model\n",
    "        mean = self.compute_mean(s)\n",
    "        \n",
    "        # Exp the logstdv to avoid negative values and clamp the stdv between 1e-3 and 50\n",
    "        stdv = torch.clamp(self.logstdv.exp(), 1e-3, 50)\n",
    "        \n",
    "        # Sample an action from the normal distribution\n",
    "        return torch.distributions.Normal(mean, stdv)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay Buffer\n",
    "\n",
    "Experience replay is a technique very similar to planning in RL. Overall, this technique is used to update the action-values of the agent with a set of \"experience\" collected in a model. This experience allows the model to learn without interacting with the environment using simulated experience.\n",
    "\n",
    "Experience replay is a simple method that can get some of the advantages of planning by saving a buffer of experience and using the data stored in the buffer as a model. This view of prior data as a model works because the data represents actual transitions from the underlying MDP. The data stored in the model are the state, action, reward and next state. \n",
    "\n",
    "The model will be filled until a queue size is reached, only then the model will drop its oldest observation and add a new one. With this buffer of information, it is possible to sample \"batches\" and update the action values of the agent.\n",
    "\n",
    "As a quick recap, the next pseudocode shows the pseudocode for Dyna-Q algorithm where the agent performs planning steps, improving the learning process of the agent with simulated experience.\n",
    "\n",
    "<img src=\"./assets/dyna-q.png\" width=\"480\" />\n",
    "\n",
    "The planning process is given in the next image.\n",
    "\n",
    "<img src=\"./assets/planning.png\" width=\"320\" />\n",
    "\n",
    "For further information about planning see [Section 8.2 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=185). **Note**: Images taken from the last reference.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size, minibatch_size):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            size (integer): The size of the replay buffer.              \n",
    "            minibatch_size (integer): The sample size.\n",
    "        \"\"\"\n",
    "        # Create the buffer\n",
    "        self.buffer = [] \n",
    "        self.minibatch_size = minibatch_size\n",
    "        self.max_size = size\n",
    "\n",
    "    def append(self, state, action, reward, terminal, next_state):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            state (Numpy array): The state of size (state_dim)            \n",
    "            action (integer): The action.\n",
    "            reward (float): The reward.\n",
    "            terminal (integer): 1 if the next state is a terminal state and 0 otherwise.\n",
    "            next_state (Numpy array): The next state of size (state_dim) .           \n",
    "        \"\"\"\n",
    "        if len(self.buffer) == self.max_size:\n",
    "            # Delete first position of the buffer if the Queue size is equals to max size\n",
    "            del self.buffer[0]\n",
    "        # Append new step\n",
    "        self.buffer.append([state, action, reward, terminal, next_state])\n",
    "\n",
    "    def sample(self):\n",
    "        \"\"\"\n",
    "        Returns:\n",
    "            A list of transition tuples including state, action, reward, terinal, and next_state\n",
    "            The return of this function is of size (minibatch_size)\n",
    "        \"\"\"\n",
    "        idxs = np.random.choice(np.arange(len(self.buffer)), size=self.minibatch_size)\n",
    "        return [self.buffer[idx] for idx in idxs]\n",
    "\n",
    "    def size(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing TD target and TD estimate\n",
    "\n",
    "The TD target and TD estimate's computation will be done in the next lines. The main idea here is to obtain both TD values from the Critic's network.\n",
    "\n",
    "At time $t$, there is a value estimate function represented as a neural network, say $V_t$. The idea is to update the value estimates function and get a new one we can use at the next timestep. We will get this $V_{t+1}$ using multiple replay steps that each result in an intermediate Value estimate function $V_{t+1}^{i}$ where $i$ indexes which replay step we are at.\n",
    "\n",
    "In each replay step, we sample a batch of experiences from the replay buffer and compute a minibatch TD(0) update (Critic) + Actor critic update. Across these N replay steps, we will use the current \"un-updated\" value estimate network at time $t$, $V_t$, for computing the value estimate of the next-states. This contrasts using the most recent action-values from the last replay step $V_{t+1}^{i}$. We make this choice to have targets that are stable across replay steps. Here is the pseudocode for performing the updates:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "& Q_t \\leftarrow \\text{action-value network at timestep t (current action-value network)}\\\\\n",
    "& \\text{Initialize } V_{t+1}^1 \\leftarrow V_t\\\\\n",
    "& \\text{For } i \\text{ in } [1, ..., N] \\text{ (i.e. N} \\text{  replay steps)}:\\\\\n",
    "& \\hspace{1cm} s, a, r, t, s'\n",
    "\\leftarrow \\text{Sample batch of experiences from experience replay buffer} \\\\\n",
    "& \\hspace{1cm} \\text{Do TD(0) update with } V_t: V_{t+1}^{i+1}(s, w) \\leftarrow V_{t}^{i}(s, w) + \\alpha \\cdot \\left[r + \\gamma \\left(V_t(s', w)\\right) - V_{t+1}^{i}(s, w)\\right]\\\\\n",
    "& \\hspace{1.5cm} \\text{ making sure to add the } \\gamma \\left(V_t(s', w)\\right) \\text{ for non-terminal transitions only.} \\\\\n",
    "& \\text{After N replay steps, we set } V_{t+1}^{N} \\text{ as } V_{t+1} \\text{ and have a new } V_{t+1} \\text{for time step } t + 1 \\text{ that we will fix in the next set of updates. }\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "\n",
    "The TD error is composed of two values, the TD estimate and TD Target.\n",
    "\n",
    "$$ \\delta = [R_{t+1} + \\gamma \\hat{v}(S_{t+1}, w) - \\hat{v}(s_t,w)] = \\text{TD error} $$\n",
    " \n",
    "Recall that the TD Target is given by.\n",
    "\n",
    "$$ R_{t+1} + \\gamma \\hat{v}(S_{t+1}, w) $$\n",
    "\n",
    "Similarly, the TD estimate is.\n",
    "\n",
    "$$ \\hat{v}(s_t,w) $$\n",
    "\n",
    "\n",
    "For further explanation about TD methods see [Section 6.1 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=141)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Method to compute the TD Target and TD estimate\n",
    "def get_td(states, next_states, rewards, terminals, critic, current_critic, discount):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        states (Numpy array): States with shape (state_dim).\n",
    "        next_states (Numpy array): Next states with shape (state_dim).\n",
    "        rewards (float): Current reward.\n",
    "        terminals (float): Terminal state.\n",
    "        critic (Critic): The critic neural network used to compute value estimates\n",
    "        discount (float): The discount factor (gamma).\n",
    "    Returns:\n",
    "        target_vec (Tensor value): The TD Target.\n",
    "        estimate_vec (Tensor value): The TD estimate.\n",
    "    \"\"\"\n",
    "    # Compute value estimates for the next states with the fixed network\n",
    "    v_next_vals = current_critic.forward(next_states)\n",
    "    # Compute value estimates for the current states (TD estimate) with the trainable network\n",
    "    v_curr_vals = critic.forward(states).squeeze()\n",
    "    \n",
    "    # Compute the TD Target\n",
    "    target_vec = torch.tensor(rewards) + (discount * v_next_vals.squeeze() * (1 - torch.tensor(terminals)))\n",
    "    \n",
    "    return target_vec, v_curr_vals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing Network's optmizer\n",
    "\n",
    "One important step is to optimize the network using the TD estimate and the TD target computed previously. As a quick recap, the Mean squared value error is used as loss function for the Critic.\n",
    "\n",
    "$$\\overline{VE} = \\sum_s\\mu(s)[V_\\pi(s) - \\hat{v}(s,w)]^2$$\n",
    "\n",
    "Similarly, the loss function for the Actor newtork is given as follows:\n",
    "\n",
    "$$ ActorLoss = \\nabla \\ln \\pi(a_t | s_t, \\theta_t) q_\\pi(s_t,a_t) $$\n",
    "\n",
    "The idea is to use $\\overline{VE}$ as the Loss function to optimize the value estimates network. The actor's weights will be updated using gradient ascent with a different cost function. For this particular problem, the MSE implementation provided by Pytorch is used. Additionally, the Adam optimizer is used to optimize both actor and critis's weights.\n",
    "\n",
    "See [Section 9.2 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=221) and [Section 13.3 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=348)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_network(experiences, discount, optimizer_c, optimizer_a, actor, critic, current_critic, criterion):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        experiences (Numpy array): The batch of experiences including the states, actions, \n",
    "                                   rewards, terminals, and next_states.\n",
    "        discount (float): The discount factor.\n",
    "        network (ActionValueNetwork): The latest state of the network that is getting replay updates.\n",
    "        current_q (ActionValueNetwork): The fixed network used for computing the targets, \n",
    "                                        and particularly, the action-values at the next-states.\n",
    "    Return:\n",
    "        Loss (float): The loss value for the current batch.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Get states, action, rewards, terminals, and next_states from experiences\n",
    "    states, actions, rewards, terminals, next_states = map(list, zip(*experiences))\n",
    "    states = np.concatenate(states) # Batch per states\n",
    "    next_states = np.concatenate(next_states) # Batch per states\n",
    "    rewards = np.array(rewards) # Batch size\n",
    "    terminals = np.array(terminals) # Batch size\n",
    "    batch_size = states.shape[0] # Batch size\n",
    "    \n",
    "    # Computing TD target and estimate using get_td function\n",
    "    td_target, td_estimate = get_td(states, next_states, rewards, terminals, critic, current_critic, discount)\n",
    "    \n",
    "    # TD error calculation\n",
    "    delta = td_target - td_estimate\n",
    "\n",
    "    # Critic\n",
    "    # zero the gradients buffer\n",
    "    optimizer_c.zero_grad()\n",
    "    # Compute the  Mean squared value error loss\n",
    "    critic_loss = criterion(td_estimate.double().to(device), td_target.double().to(device))\n",
    "    # Backprop the error\n",
    "    critic_loss.backward()\n",
    "    # Clip the gradients to 0.5\n",
    "    clip_grad_norm_(optimizer_c, 0.5)\n",
    "    # Optimize critic's network\n",
    "    optimizer_c.step()\n",
    "\n",
    "    # Actor \n",
    "    optimizer_a.zero_grad()\n",
    "    # Compute mu and sigma\n",
    "    norm_dists = actor.forward(states)\n",
    "    # Construct equivalent loss function\n",
    "    logs_probs = norm_dists.log_prob(torch.tensor(actions))\n",
    "    # Multiply by minus one as this is gradient ascent\n",
    "    actor_loss = (-logs_probs * delta.detach()).mean()\n",
    "    # Backprop the error\n",
    "    actor_loss.backward()\n",
    "    # Clip the actor's gradients\n",
    "    clip_grad_norm_(optimizer_a, 0.5)\n",
    "    # Optimize the actor's network\n",
    "    optimizer_a.step()\n",
    "    \n",
    "    return actor_loss.detach().numpy(), critic_loss.detach().numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clipping the gradients\n",
    "\n",
    "To guarantee stability in the training process, it is necessary to clip the gradients of the networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clip_grad_norm_(module, max_grad_norm):\n",
    "    nn.utils.clip_grad_norm_([p for g in module.param_groups for p in g[\"params\"]], max_grad_norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementing Actor-Critic Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final step is to implement the Agent. The training process is cyclical as this is a continuous task and the sequence goes as follows.\n",
    "\n",
    "$\\delta_t = R_{t+1}  + \\gamma \\hat{v}(S_{t+1}, \\mathbf{w}) - \\hat{v}(S_{t}, \\mathbf{w}) \\hspace{6em}  (1)$\n",
    "\n",
    "**Critic weight update rule**: $\\mathbf{w} \\leftarrow \\mathbf{w} + \\alpha^{\\mathbf{w}}\\delta\\nabla \\hat{v}(s,\\mathbf{w}) \\hspace{2.5em} (2)$\n",
    "\n",
    "**Actor weight update rule**: $\\mathbf{\\theta} \\leftarrow \\mathbf{\\theta} + \\alpha^{\\mathbf{\\theta}}\\delta\\nabla ln \\pi(A|S,\\mathbf{\\theta}) \\hspace{1.4em} (3)$\n",
    "\n",
    "The Actor-critic algorithm is presented in the next image. The actor produces a policy (action) that is \n",
    "immediately evaluated by the critic.\n",
    "\n",
    "<img src=\"./assets/actor_critic.png\" width=\"240\" />\n",
    "\n",
    "For further details, see [Section 13.5 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=353). **Note**: Image taken from [Reinforcement learning specialization, C3L4S4](https://www.coursera.org/learn/prediction-control-function-approximation/lecture/h9nDv/actor-critic-algorithm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Actor-Critic Agent\n",
    "class ActorCritic():\n",
    "    \"\"\"\n",
    "    Initialization of Actor-Critic Agent. All values are set to None so they can\n",
    "    be initialized in the agent_init method.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\"\"\"\n",
    "        self.actor_step_size = None\n",
    "        self.critic_step_size = None\n",
    "        self.avg_reward_step_size = None\n",
    "\n",
    "        self.avg_reward = None\n",
    "        self.critic = None\n",
    "        self.actor = None\n",
    "\n",
    "        self.actions = None\n",
    "\n",
    "        self.last_action = None\n",
    "        self.last_state = None\n",
    "\n",
    "    def agent_init(self, agent_config = {}):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\"\"\"\n",
    "        \n",
    "        # Step size parameters\n",
    "        self.actor_step_size = agent_config['optimizers_config']['actor_step_size']\n",
    "        self.critic_step_size = agent_config['optimizers_config']['critic_step_size']\n",
    "        self.discount = agent_config['optimizers_config']['gamma']\n",
    "        \n",
    "        # Set number of actions\n",
    "        self.actions = agent_config['network_config']['num_actions']\n",
    "        \n",
    "        # Initialize actor and critic networks\n",
    "        self.actor = Actor(agent_config['network_config']).to(device)\n",
    "        self.critic = Critic(agent_config['network_config']).to(device)\n",
    "        \n",
    "        # Critic Loss\n",
    "        self.critic_loss = nn.MSELoss()\n",
    "        \n",
    "        # Create replay buffer\n",
    "        self.replay_buffer = ReplayBuffer(agent_config['replay_buffer_size'], \n",
    "                                          agent_config['minibatch_sz'])\n",
    "        # Number of times a minibatches that will be passed\n",
    "        self.num_replay = agent_config['num_replay_updates_per_step']\n",
    "        \n",
    "        # Loss variables\n",
    "        self.actor_loss_val = 0\n",
    "        self.critic_loss_val = 0\n",
    "        \n",
    "        # Actor and Critic optimizer\n",
    "        self.actor_opti = optim.Adam(self.actor.parameters(), lr = self.actor_step_size ) \n",
    "        self.critic_opti = optim.Adam(self.critic.parameters(), lr = self.critic_step_size )\n",
    "        \n",
    "        self.last_action = None\n",
    "        self.last_state = None\n",
    "\n",
    "    def select_action(self, state):\n",
    "        \"\"\"\n",
    "        Selects an action using epsilon greedy\n",
    "        Args:\n",
    "            state (Numpy array): the state.\n",
    "        Returns:\n",
    "            chosen_action (float)\n",
    "        \"\"\"\n",
    "        # Pass the states to create the normal distribution\n",
    "        dist = self.actor.forward(state)\n",
    "        # Sample an action from the current normal Distribution\n",
    "        action = dist.sample().detach().data.numpy()\n",
    "        # Clip action to a given range (Max and Min in action space)\n",
    "        chosen_action = np.clip(action, env.action_space.low.min(), env.action_space.high.max())\n",
    "\n",
    "        return chosen_action\n",
    "    \n",
    "    def agent_start(self, state):\n",
    "        \"\"\"The first method called when the experiment starts, called after\n",
    "        the environment starts.\n",
    "        Args:\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's env.reset() function.\n",
    "        Returns:\n",
    "            The first action the agent takes.\n",
    "        \"\"\"\n",
    "        # Select an action given the current state\n",
    "        current_action = self.select_action(state)\n",
    "        # Save action as last action\n",
    "        self.last_action = current_action\n",
    "        # Save tiles as previous tiles\n",
    "        self.last_state = np.array([state])\n",
    "        \n",
    "        return self.last_action\n",
    "\n",
    "    def agent_step(self, reward, state):\n",
    "        \"\"\"A step taken by the agent.\n",
    "        Args:\n",
    "            reward (float): the reward received for taking the last action taken\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's step based, where the agent ended up after the\n",
    "                last step\n",
    "        Returns:\n",
    "            The action the agent is taking.\n",
    "        \"\"\"\n",
    "        # Select action\n",
    "        action = self.select_action(state)\n",
    "        # New state\n",
    "        state = np.array([state])\n",
    "\n",
    "        # Append new experience to replay buffer\n",
    "        self.replay_buffer.append(self.last_state, self.last_action, reward, 0, state)\n",
    "        # Perform replay steps:\n",
    "        if self.replay_buffer.size() > self.replay_buffer.minibatch_size:\n",
    "            # Make a copy of the current network to obtain stable targets\n",
    "            current_c = deepcopy(self.critic)\n",
    "            for _ in range(self.num_replay):                \n",
    "                # Get sample experiences from the replay buffer\n",
    "                experiences = self.replay_buffer.sample()\n",
    "                # Call optimize_network to update the weights of the network (~1 Line)\n",
    "                self.actor_loss_val, self.critic_loss_val = optimize_network(experiences, self.discount, \n",
    "                                                                             self.critic_opti, self.actor_opti, \n",
    "                                                                             self.actor, self.critic, current_c,\n",
    "                                                                             self.critic_loss)\n",
    "        # Store state, action\n",
    "        self.last_state = state\n",
    "        self.last_action = action\n",
    "\n",
    "        return self.last_action\n",
    "\n",
    "    def agent_end(self, reward):\n",
    "        \"\"\"Run when the agent terminates.\n",
    "        Args:\n",
    "            reward (float): the reward the agent received for entering the\n",
    "                terminal state.\n",
    "        \"\"\"\n",
    "\n",
    "        # There is no action_value used here because this is the end\n",
    "        # of the episode.\n",
    "        \n",
    "        # Create state full of zeroes\n",
    "        state = np.zeros_like(self.last_state)\n",
    "        \n",
    "\n",
    "        \n",
    "        # Append new experience to replay buffer\n",
    "        self.replay_buffer.append(self.last_state, self.last_action, reward, 0, state)\n",
    "        # Perform replay steps:\n",
    "        if self.replay_buffer.size() > self.replay_buffer.minibatch_size:\n",
    "            # Make a copy of the current network to obtain stable targets\n",
    "            current_c = deepcopy(self.critic)\n",
    "            for _ in range(self.num_replay):                \n",
    "                # Get sample experiences from the replay buffer\n",
    "                experiences = self.replay_buffer.sample()\n",
    "                # Call optimize_network to update the weights of the network (~1 Line)\n",
    "                self.actor_loss_val, self.critic_loss_val = optimize_network(experiences, self.discount, \n",
    "                                                                             self.critic_opti, self.actor_opti, \n",
    "                                                                             self.actor, self.critic, current_c,\n",
    "                                                                             self.critic_loss)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the experiment\n",
    "\n",
    "The following lines solves the Pendulum problem and plot the average reward obtained over episodes and steps taken to solve the challenge at a specific episode (The experiment is over every x amount of steps)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 150/150 [10:17<00:00,  4.12s/it]\n"
     ]
    }
   ],
   "source": [
    "# Test the Actor-Critic agent\n",
    "\n",
    "num_runs = 1\n",
    "num_episodes = 150\n",
    "\n",
    "agent_info = {\n",
    "             'network_config': {\n",
    "                 'state_dim': env.observation_space.shape[0],\n",
    "                 'num_hidden_units': 64,\n",
    "                 'num_actions': env.action_space.shape[0]\n",
    "             },\n",
    "             'optimizers_config': {\n",
    "                 'actor_step_size': 4e-4,  #5e-6, 1e-5 \n",
    "                 'critic_step_size': 4e-3, # 4e-4, 4e-3\n",
    "                 'gamma': 0.9, \n",
    "             },\n",
    "                'replay_buffer_size': 50000,\n",
    "                'minibatch_sz': 16,\n",
    "                'num_replay_updates_per_step': 4}\n",
    "            \n",
    "# Variable to save the rewards in an episode\n",
    "all_rewards = []\n",
    "# Save actor and critic losses\n",
    "all_loss_c = []\n",
    "all_loss_a = []\n",
    "\n",
    "# Agent\n",
    "agent = ActorCritic()\n",
    "\n",
    "# Environment\n",
    "env = gym.make('Pendulum-v0')\n",
    "env.reset()\n",
    "# Maximum number of possible iterations (default was 200)\n",
    "env._max_episode_steps = 200\n",
    "\n",
    "# Number of runs are the times the experiment will start again (a.k.a episode)\n",
    "for n_runs in range(num_runs):\n",
    "    \n",
    "    # Resets environment\n",
    "    observation = env.reset()\n",
    "    # Reset agent\n",
    "    agent.agent_init(agent_info)\n",
    "    # Generate last state and action in the agent\n",
    "    last_action = agent.agent_start(observation)\n",
    "    # Steps, rewards and loss at each episode to solve the challenge\n",
    "    rewards_per_episode = []\n",
    "    loss_per_episode_c = []\n",
    "    loss_per_episode_a = []\n",
    "        \n",
    "    # Times the environment will start again without resetting the agent\n",
    "    for t in tqdm(range(num_episodes)):\n",
    "        \n",
    "        # Reset done flag\n",
    "        done = False\n",
    "        # Set rewards, steps and loss to zero\n",
    "        rewards = 0\n",
    "        agent.actor_loss_val = 0\n",
    "        agent.critic_loss_val = 0\n",
    "        # Reset environment\n",
    "        observation = env.reset()\n",
    "        # Run until the experiment is over\n",
    "        while not done:\n",
    "            \n",
    "            # Render the environment \n",
    "            env.render()\n",
    "\n",
    "            # Take a step with the environment\n",
    "            observation, reward, done, info = env.step(last_action)\n",
    "            \n",
    "            rewards += reward.squeeze()\n",
    "\n",
    "            # If the goal has been reached stop\n",
    "            if done:\n",
    "                # Last step with the agent\n",
    "                agent.agent_end(reward)\n",
    "            else:\n",
    "                # Take a step with the agent\n",
    "                last_action = agent.agent_step(reward, observation)\n",
    "                \n",
    "        # Reward obtained during the episode\n",
    "        rewards_per_episode.append(rewards)\n",
    "        # Losses obtained solving the experiment\n",
    "        loss_per_episode_c.append(agent.critic_loss_val)\n",
    "        loss_per_episode_a.append(agent.actor_loss_val)\n",
    "\n",
    "\n",
    "    # Awards obtained during all episode\n",
    "    all_rewards.append(np.array(rewards_per_episode))\n",
    "    # Losses obtained during all episodes\n",
    "    all_loss_c.append(np.array(loss_per_episode_c))\n",
    "    all_loss_a.append(np.array(loss_per_episode_a))\n",
    "\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best reward obtained solving the experiment was: -1.225467514357815\n",
      "\n",
      "The WorSt reward obtained solving the experiment was: -1652.5802197851567\n",
      "\n"
     ]
    }
   ],
   "source": [
    "rewards_average = np.mean(all_rewards, axis=0)\n",
    "plt.plot(rewards_average, label = 'Average Reward')\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Sum of\\n rewards\\n during\\n episodes\" ,rotation=0, labelpad=40)\n",
    "plt.xlim(-0.2, num_episodes)\n",
    "plt.ylim(rewards_average.min(), rewards_average.max())\n",
    "plt.title(\"Average iterations to solve the experiment over runs\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "print(\"The best reward obtained solving the experiment was: {0}\\n\".format(np.array(all_rewards).max()))\n",
    "print(\"The WorSt reward obtained solving the experiment was: {0}\\n\".format(np.array(all_rewards).min()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best loss obtained with the Critic solving the experiment was: 0.2563592920590998\n",
      "\n",
      "The Worst loss obtained with the Critic solving the experiment was: 345.100829997527\n",
      "\n"
     ]
    }
   ],
   "source": [
    "loss_average = np.mean(np.array(all_loss_c), axis=0)\n",
    "plt.plot(loss_average, label = 'Steps')\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Average loss\",rotation=0, labelpad=40)\n",
    "plt.xlim(-0.2, num_episodes)\n",
    "plt.ylim(loss_average.min(), loss_average.max())\n",
    "plt.title(\"Average loss over iterations (Critic)\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "print(\"The best loss obtained with the Critic solving the experiment was: {0}\\n\".format(np.array(loss_average).min()))\n",
    "print(\"The Worst loss obtained with the Critic solving the experiment was: {0}\\n\".format(np.array(loss_average).max()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best loss obtained with the Actor solving the experiment was: 8.754470956925347\n",
      "\n",
      "The Worst loss obtained with the Actor solving the experiment was: -6.190843980750689\n",
      "\n"
     ]
    }
   ],
   "source": [
    "loss_average = np.mean(np.array(all_loss_a), axis=0)\n",
    "plt.plot(loss_average, label = 'Steps')\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Average loss\",rotation=0, labelpad=40)\n",
    "plt.xlim(-0.2, num_episodes)\n",
    "plt.ylim(loss_average.min(), loss_average.max())\n",
    "plt.title(\"Average loss over iterations (Actor)\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "print(\"The best loss obtained with the Actor solving the experiment was: {0}\\n\".format(np.array(loss_average).max()))\n",
    "print(\"The Worst loss obtained with the Actor solving the experiment was: {0}\\n\".format(np.array(loss_average).min()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using the last trained Agent \n",
    "\n",
    "This lines shows in a video the performance of the last trained agent and save a video with the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/1 [00:00<?, ?it/s]\n",
      "  0%|          | 0/300 [00:00<?, ?it/s]\u001b[A\n",
      "  1%|          | 3/300 [00:00<00:11, 25.78it/s]\u001b[A\n",
      "  2%|▏         | 6/300 [00:00<00:11, 24.64it/s]\u001b[A\n",
      "  3%|▎         | 9/300 [00:00<00:12, 24.13it/s]\u001b[A\n",
      "  4%|▍         | 12/300 [00:00<00:11, 24.55it/s]\u001b[A\n",
      "  5%|▌         | 15/300 [00:00<00:11, 24.76it/s]\u001b[A\n",
      "  6%|▌         | 18/300 [00:00<00:11, 24.53it/s]\u001b[A\n",
      "  7%|▋         | 21/300 [00:00<00:11, 24.26it/s]\u001b[A\n",
      "  8%|▊         | 24/300 [00:00<00:11, 24.31it/s]\u001b[A\n",
      "  9%|▉         | 27/300 [00:01<00:11, 23.97it/s]\u001b[A\n",
      " 10%|█         | 30/300 [00:01<00:11, 23.54it/s]\u001b[A\n",
      " 11%|█         | 33/300 [00:01<00:11, 24.02it/s]\u001b[A\n",
      " 12%|█▏        | 36/300 [00:01<00:11, 23.78it/s]\u001b[A\n",
      " 13%|█▎        | 39/300 [00:01<00:11, 23.49it/s]\u001b[A\n",
      " 14%|█▍        | 42/300 [00:01<00:11, 22.63it/s]\u001b[A\n",
      " 15%|█▌        | 45/300 [00:01<00:11, 22.80it/s]\u001b[A\n",
      " 16%|█▌        | 48/300 [00:02<00:11, 22.81it/s]\u001b[A\n",
      " 17%|█▋        | 51/300 [00:02<00:10, 23.09it/s]\u001b[A\n",
      " 18%|█▊        | 54/300 [00:02<00:10, 22.66it/s]\u001b[A\n",
      " 19%|█▉        | 57/300 [00:02<00:10, 23.93it/s]\u001b[A\n",
      " 20%|██        | 60/300 [00:02<00:09, 24.07it/s]\u001b[A\n",
      " 21%|██        | 63/300 [00:02<00:09, 23.84it/s]\u001b[A\n",
      " 22%|██▏       | 66/300 [00:02<00:09, 23.68it/s]\u001b[A\n",
      " 23%|██▎       | 69/300 [00:02<00:09, 23.66it/s]\u001b[A\n",
      " 24%|██▍       | 72/300 [00:03<00:09, 23.84it/s]\u001b[A\n",
      " 25%|██▌       | 75/300 [00:03<00:09, 24.16it/s]\u001b[A\n",
      " 26%|██▌       | 78/300 [00:03<00:09, 23.87it/s]\u001b[A\n",
      " 27%|██▋       | 81/300 [00:03<00:09, 23.34it/s]\u001b[A\n",
      " 28%|██▊       | 84/300 [00:03<00:09, 23.19it/s]\u001b[A\n",
      " 29%|██▉       | 87/300 [00:03<00:09, 23.42it/s]\u001b[A\n",
      " 30%|███       | 90/300 [00:03<00:09, 23.09it/s]\u001b[A\n",
      " 31%|███       | 93/300 [00:03<00:09, 22.87it/s]\u001b[A\n",
      " 32%|███▏      | 96/300 [00:04<00:08, 23.03it/s]\u001b[A\n",
      " 33%|███▎      | 99/300 [00:04<00:08, 22.84it/s]\u001b[A\n",
      " 34%|███▍      | 102/300 [00:04<00:08, 22.90it/s]\u001b[A\n",
      " 35%|███▌      | 105/300 [00:04<00:08, 23.31it/s]\u001b[A\n",
      " 36%|███▌      | 108/300 [00:04<00:08, 23.81it/s]\u001b[A\n",
      " 37%|███▋      | 111/300 [00:04<00:07, 23.76it/s]\u001b[A\n",
      " 38%|███▊      | 114/300 [00:04<00:08, 22.95it/s]\u001b[A\n",
      " 39%|███▉      | 117/300 [00:04<00:08, 22.85it/s]\u001b[A\n",
      " 40%|████      | 120/300 [00:05<00:07, 22.95it/s]\u001b[A\n",
      " 41%|████      | 123/300 [00:05<00:07, 22.57it/s]\u001b[A\n",
      " 42%|████▏     | 126/300 [00:05<00:07, 22.17it/s]\u001b[A\n",
      " 43%|████▎     | 129/300 [00:05<00:07, 21.61it/s]\u001b[A\n",
      " 44%|████▍     | 132/300 [00:05<00:07, 21.03it/s]\u001b[A\n",
      " 45%|████▌     | 135/300 [00:05<00:08, 20.05it/s]\u001b[A\n",
      " 46%|████▌     | 138/300 [00:06<00:08, 19.73it/s]\u001b[A\n",
      " 47%|████▋     | 140/300 [00:06<00:08, 19.17it/s]\u001b[A\n",
      " 47%|████▋     | 142/300 [00:06<00:08, 18.40it/s]\u001b[A\n",
      " 48%|████▊     | 144/300 [00:06<00:08, 17.92it/s]\u001b[A\n",
      " 49%|████▊     | 146/300 [00:06<00:08, 17.59it/s]\u001b[A\n",
      " 50%|████▉     | 149/300 [00:06<00:07, 19.24it/s]\u001b[A\n",
      " 51%|█████     | 152/300 [00:06<00:07, 20.24it/s]\u001b[A\n",
      " 52%|█████▏    | 155/300 [00:06<00:06, 21.01it/s]\u001b[A\n",
      " 53%|█████▎    | 158/300 [00:06<00:06, 21.74it/s]\u001b[A\n",
      " 54%|█████▎    | 161/300 [00:07<00:06, 22.28it/s]\u001b[A\n",
      " 55%|█████▍    | 164/300 [00:07<00:06, 22.65it/s]\u001b[A\n",
      " 56%|█████▌    | 167/300 [00:07<00:05, 22.19it/s]\u001b[A\n",
      " 57%|█████▋    | 170/300 [00:07<00:05, 22.59it/s]\u001b[A\n",
      " 58%|█████▊    | 173/300 [00:07<00:05, 21.72it/s]\u001b[A\n",
      " 59%|█████▊    | 176/300 [00:07<00:05, 21.58it/s]\u001b[A\n",
      " 60%|█████▉    | 179/300 [00:07<00:05, 21.46it/s]\u001b[A\n",
      " 61%|██████    | 182/300 [00:08<00:05, 22.32it/s]\u001b[A\n",
      " 62%|██████▏   | 185/300 [00:08<00:04, 23.07it/s]\u001b[A\n",
      " 63%|██████▎   | 188/300 [00:08<00:04, 23.64it/s]\u001b[A\n",
      " 64%|██████▎   | 191/300 [00:08<00:04, 22.95it/s]\u001b[A\n",
      " 65%|██████▍   | 194/300 [00:08<00:04, 22.37it/s]\u001b[A\n",
      " 66%|██████▌   | 197/300 [00:08<00:04, 22.17it/s]\u001b[A\n",
      " 67%|██████▋   | 200/300 [00:08<00:04, 22.63it/s]\u001b[A\n",
      " 68%|██████▊   | 203/300 [00:08<00:04, 22.82it/s]\u001b[A\n",
      " 69%|██████▊   | 206/300 [00:09<00:04, 23.34it/s]\u001b[A\n",
      " 70%|██████▉   | 209/300 [00:09<00:04, 22.58it/s]\u001b[A\n",
      " 71%|███████   | 212/300 [00:09<00:03, 22.55it/s]\u001b[A\n",
      " 72%|███████▏  | 215/300 [00:09<00:04, 19.62it/s]\u001b[A\n",
      " 73%|███████▎  | 218/300 [00:09<00:04, 18.97it/s]\u001b[A\n",
      " 74%|███████▎  | 221/300 [00:09<00:03, 20.09it/s]\u001b[A\n",
      " 75%|███████▍  | 224/300 [00:10<00:03, 20.14it/s]\u001b[A\n",
      " 76%|███████▌  | 227/300 [00:10<00:03, 19.83it/s]\u001b[A\n",
      " 77%|███████▋  | 230/300 [00:10<00:03, 20.41it/s]\u001b[A\n",
      " 78%|███████▊  | 233/300 [00:10<00:03, 19.11it/s]\u001b[A\n",
      " 78%|███████▊  | 235/300 [00:10<00:03, 18.93it/s]\u001b[A\n",
      " 79%|███████▉  | 237/300 [00:10<00:03, 17.52it/s]\u001b[A\n",
      " 80%|███████▉  | 239/300 [00:10<00:03, 17.93it/s]\u001b[A\n",
      " 80%|████████  | 241/300 [00:10<00:03, 17.49it/s]\u001b[A\n",
      " 81%|████████  | 243/300 [00:11<00:03, 16.80it/s]\u001b[A\n",
      " 82%|████████▏ | 245/300 [00:11<00:03, 16.98it/s]\u001b[A\n",
      " 83%|████████▎ | 248/300 [00:11<00:02, 18.71it/s]\u001b[A\n",
      " 84%|████████▎ | 251/300 [00:11<00:02, 20.00it/s]\u001b[A\n",
      " 85%|████████▍ | 254/300 [00:11<00:02, 21.11it/s]\u001b[A\n",
      " 86%|████████▌ | 257/300 [00:11<00:02, 20.96it/s]\u001b[A\n",
      " 87%|████████▋ | 260/300 [00:11<00:01, 20.33it/s]\u001b[A\n",
      " 88%|████████▊ | 263/300 [00:12<00:01, 20.35it/s]\u001b[A\n",
      " 89%|████████▊ | 266/300 [00:12<00:01, 20.69it/s]\u001b[A\n",
      " 90%|████████▉ | 269/300 [00:12<00:01, 20.93it/s]\u001b[A\n",
      " 91%|█████████ | 272/300 [00:12<00:01, 20.21it/s]\u001b[A\n",
      " 92%|█████████▏| 275/300 [00:12<00:01, 21.62it/s]\u001b[A\n",
      " 93%|█████████▎| 278/300 [00:12<00:00, 22.82it/s]\u001b[A\n",
      " 94%|█████████▎| 281/300 [00:12<00:00, 24.58it/s]\u001b[A\n",
      " 95%|█████████▌| 285/300 [00:12<00:00, 27.28it/s]\u001b[A\n",
      " 96%|█████████▋| 289/300 [00:13<00:00, 28.70it/s]\u001b[A\n",
      " 98%|█████████▊| 293/300 [00:13<00:00, 30.64it/s]\u001b[A\n",
      "100%|█████████▉| 299/300 [00:13<00:00, 22.38it/s]\u001b[A\n",
      "100%|██████████| 1/1 [00:13<00:00, 13.52s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode finished with a total reward of\n"
     ]
    }
   ],
   "source": [
    "# Test Sarsa Agent \n",
    "num_runs = 1\n",
    "num_episodes = 300\n",
    "\n",
    "# Environment\n",
    "env_to_wrap = gym.make('Pendulum-v0')\n",
    "# Maximum number of possible iterations (default was 200)\n",
    "env_to_wrap._max_episode_steps = 300\n",
    "env = Monitor(env_to_wrap, \"./videos/pendulum\", video_callable=lambda episode_id: True, force=True)\n",
    "total_reward = 0\n",
    "\n",
    "# Number of runs are the times the experiment will start again (a.k.a episode)\n",
    "for n_runs in tqdm(range(num_runs)):\n",
    "    \n",
    "    # Resets environment\n",
    "    observation = env.reset()\n",
    "    # Generate last state and action in the agent\n",
    "    last_action = agent.agent_start(observation)\n",
    "        \n",
    "    # Times the environment will start again without resetting the agent\n",
    "    for t in tqdm(range(num_episodes)):\n",
    "\n",
    "        # View environment\n",
    "        env.render()\n",
    "\n",
    "        # Take a step with the environment\n",
    "        observation, reward, done, info = env.step(last_action)\n",
    "        total_reward += reward\n",
    "        \n",
    "\n",
    "        # If the goal has been reached stop\n",
    "        if done:\n",
    "            # Last step with the agent\n",
    "            agent.agent_end(reward)\n",
    "            break\n",
    "\n",
    "        else:\n",
    "            # Take a step with the agent\n",
    "            last_action = agent.agent_step(reward, observation)\n",
    "\n",
    "\n",
    "env.close()\n",
    "env_to_wrap.close()\n",
    "\n",
    "print(\"Episode finished with a total reward of\".format(total_reward))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}