1_getting_started.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "1_getting_started.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/araffin/rl-tutorial-jnrr19/blob/master/1_getting_started.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hyyN-2qyK_T2",
        "colab_type": "text"
      },
      "source": [
        "# Stable Baselines Tutorial - Getting Started\n",
        "\n",
        "Github repo: https://github.com/araffin/rl-tutorial-jnrr19\n",
        "\n",
        "Stable-Baselines: https://github.com/hill-a/stable-baselines\n",
        "\n",
        "Documentation: https://stable-baselines.readthedocs.io/en/master/\n",
        "\n",
        "RL Baselines zoo: https://github.com/araffin/rl-baselines-zoo\n",
        "\n",
        "Medium article: [https://medium.com/@araffin/stable-baselines-a-fork-of-openai-baselines-df87c4b2fc82](https://medium.com/@araffin/stable-baselines-a-fork-of-openai-baselines-df87c4b2fc82)\n",
        "\n",
        "[RL Baselines Zoo](https://github.com/araffin/rl-baselines-zoo) is a collection of pre-trained Reinforcement Learning agents using Stable-Baselines.\n",
        "\n",
        "It also provides basic scripts for training, evaluating agents, tuning hyperparameters and recording videos.\n",
        "\n",
        "\n",
        "## Introduction\n",
        "\n",
        "In this notebook, you will learn the basics for using stable baselines library: how to create a RL model, train it and evaluate it. Because all algorithms share the same interface, we will see how simple it is to switch from one algorithm to another.\n",
        "\n",
        "\n",
        "## Install Dependencies and Stable Baselines Using Pip\n",
        "\n",
        "List of full dependencies can be found in the [README](https://github.com/hill-a/stable-baselines).\n",
        "\n",
        "```\n",
        "sudo apt-get update && sudo apt-get install cmake libopenmpi-dev zlib1g-dev\n",
        "```\n",
        "\n",
        "\n",
        "```\n",
        "pip install stable-baselines[mpi]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gWskDE2c9WoN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Stable Baselines only supports tensorflow 1.x for now\n",
        "%tensorflow_version 1.x\n",
        "!apt-get install ffmpeg freeglut3-dev xvfb  # For visualization\n",
        "!pip install stable-baselines[mpi]==2.10.0"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FtY8FhliLsGm",
        "colab_type": "text"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gcX8hEcaUpR0",
        "colab_type": "text"
      },
      "source": [
        "Stable-Baselines works on environments that follow the [gym interface](https://stable-baselines.readthedocs.io/en/master/guide/custom_env.html).\n",
        "You can find a list of available environment [here](https://gym.openai.com/envs/#classic_control).\n",
        "\n",
        "It is also recommended to check the [source code](https://github.com/openai/gym) to learn more about the observation and action space of each env, as gym does not have a proper documentation.\n",
        "Not all algorithms can work with all action spaces, you can find more in this [recap table](https://stable-baselines.readthedocs.io/en/master/guide/algos.html)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BIedd7Pz9sOs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import gym\n",
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ae32CtgzTG3R",
        "colab_type": "text"
      },
      "source": [
        "The first thing you need to import is the RL model, check the documentation to know what you can use on which problem"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R7tKaBFrTR0a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from stable_baselines import PPO2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-0_8OQbOTTNT",
        "colab_type": "text"
      },
      "source": [
        "The next thing you need to import is the policy class that will be used to create the networks (for the policy/value functions).\n",
        "This step is optional as you can directly use strings in the constructor: \n",
        "\n",
        "```PPO2('MlpPolicy', env)``` instead of ```PPO2(MlpPolicy, env)```\n",
        "\n",
        "Note that some algorithms like `SAC` have their own `MlpPolicy` (different from `stable_baselines.common.policies.MlpPolicy`), that's why using string for the policy is the recommened option."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ROUJr675TT01",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from stable_baselines.common.policies import MlpPolicy"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RapkYvTXL7Cd",
        "colab_type": "text"
      },
      "source": [
        "## Create the Gym env and instantiate the agent\n",
        "\n",
        "For this example, we will use CartPole environment, a classic control problem.\n",
        "\n",
        "\"A pole is attached by an un-actuated joint to a cart, which moves along a frictionless track. The system is controlled by applying a force of +1 or -1 to the cart. The pendulum starts upright, and the goal is to prevent it from falling over. A reward of +1 is provided for every timestep that the pole remains upright. \"\n",
        "\n",
        "Cartpole environment: [https://gym.openai.com/envs/CartPole-v1/](https://gym.openai.com/envs/CartPole-v1/)\n",
        "\n",
        "![Cartpole](https://cdn-images-1.medium.com/max/1143/1*h4WTQNVIsvMXJTCpXm_TAw.gif)\n",
        "\n",
        "\n",
        "We chose the MlpPolicy because the observation of the CartPole task is a feature vector, not images.\n",
        "\n",
        "The type of action to use (discrete/continuous) will be automatically deduced from the environment action space\n",
        "\n",
        "Here we are using the [Proximal Policy Optimization](https://stable-baselines.readthedocs.io/en/master/modules/ppo2.html) algorithm (PPO2 is the version optimized for GPU), which is an Actor-Critic method: it uses a value function to improve the policy gradient descent (by reducing the variance).\n",
        "\n",
        "It combines ideas from [A2C](https://stable-baselines.readthedocs.io/en/master/modules/a2c.html) (having multiple workers and using an entropy bonus for exploration) and [TRPO](https://stable-baselines.readthedocs.io/en/master/modules/trpo.html) (it uses a trust region to improve stability and avoid catastrophic drops in performance).\n",
        "\n",
        "PPO is an on-policy algorithm, which means that the trajectories used to update the networks must be collected using the latest policy.\n",
        "It is usually less sample efficient than off-policy alorithms like [DQN](https://stable-baselines.readthedocs.io/en/master/modules/dqn.html), [SAC](https://stable-baselines.readthedocs.io/en/master/modules/sac.html) or [TD3](https://stable-baselines.readthedocs.io/en/master/modules/td3.html), but is much faster regarding wall-clock time.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pUWGZp3i9wyf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "env = gym.make('CartPole-v1')\n",
        "\n",
        "model = PPO2(MlpPolicy, env, verbose=0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4efFdrQ7MBvl",
        "colab_type": "text"
      },
      "source": [
        "We create a helper function to evaluate the agent:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "63M8mSKR-6Zt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def evaluate(model, num_episodes=100):\n",
        "    \"\"\"\n",
        "    Evaluate a RL agent\n",
        "    :param model: (BaseRLModel object) the RL Agent\n",
        "    :param num_episodes: (int) number of episodes to evaluate it\n",
        "    :return: (float) Mean reward for the last num_episodes\n",
        "    \"\"\"\n",
        "    # This function will only work for a single Environment\n",
        "    env = model.get_env()\n",
        "    all_episode_rewards = []\n",
        "    for i in range(num_episodes):\n",
        "        episode_rewards = []\n",
        "        done = False\n",
        "        obs = env.reset()\n",
        "        while not done:\n",
        "            # _states are only useful when using LSTM policies\n",
        "            action, _states = model.predict(obs)\n",
        "            # here, action, rewards and dones are arrays\n",
        "            # because we are using vectorized env\n",
        "            obs, reward, done, info = env.step(action)\n",
        "            episode_rewards.append(reward)\n",
        "\n",
        "        all_episode_rewards.append(sum(episode_rewards))\n",
        "\n",
        "    mean_episode_reward = np.mean(all_episode_rewards)\n",
        "    print(\"Mean reward:\", mean_episode_reward, \"Num episodes:\", num_episodes)\n",
        "\n",
        "    return mean_episode_reward"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zjEVOIY8NVeK",
        "colab_type": "text"
      },
      "source": [
        "Let's evaluate the un-trained agent, this should be a random agent."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xDHLMA6NFk95",
        "colab_type": "code",
        "outputId": "98e84e52-a750-4472-e3cd-3bb2bbc41091",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Random Agent, before training\n",
        "mean_reward_before_train = evaluate(model, num_episodes=100)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean reward: 25.09 Num episodes: 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QjjPxrwkYJ2i",
        "colab_type": "text"
      },
      "source": [
        "Stable-Baselines already provides you with that helper:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8z6K9YImYJEx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from stable_baselines.common.evaluation import evaluate_policy"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4oPTHjxyZSOL",
        "colab_type": "code",
        "outputId": "611675be-7791-4585-c5e5-f57671faf358",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=100)\n",
        "\n",
        "print(f\"mean_reward:{mean_reward:.2f} +/- {std_reward:.2f}\")"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "mean_reward:32.08 +/- 12.17\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r5UoXTZPNdFE",
        "colab_type": "text"
      },
      "source": [
        "## Train the agent and evaluate it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e4cfSXIB-pTF",
        "colab_type": "code",
        "outputId": "09f18970-5078-49ad-be59-b6c9feaa055f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Train the agent for 10000 steps\n",
        "model.learn(total_timesteps=10000)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<stable_baselines.ppo2.ppo2.PPO2 at 0x7fca48c4e240>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ygl_gVmV_QP7",
        "colab_type": "code",
        "outputId": "f03a9521-f1de-400e-db1c-b70cd9b526e1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Evaluate the trained agent\n",
        "mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=100)\n",
        "\n",
        "print(f\"mean_reward:{mean_reward:.2f} +/- {std_reward:.2f}\")"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "mean_reward:276.61 +/- 118.51\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A00W6yY3NkHG",
        "colab_type": "text"
      },
      "source": [
        "Apparently the training went well, the mean reward increased a lot ! "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xVm9QPNVwKXN",
        "colab_type": "text"
      },
      "source": [
        "### Prepare video recording"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MPyfQxD5z26J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Set up fake display; otherwise rendering will fail\n",
        "import os\n",
        "os.system(\"Xvfb :1 -screen 0 1024x768x24 &\")\n",
        "os.environ['DISPLAY'] = ':1'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SLzXxO8VMD6N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import base64\n",
        "from pathlib import Path\n",
        "\n",
        "from IPython import display as ipythondisplay\n",
        "\n",
        "def show_videos(video_path='', prefix=''):\n",
        "  \"\"\"\n",
        "  Taken from https://github.com/eleurent/highway-env\n",
        "\n",
        "  :param video_path: (str) Path to the folder containing videos\n",
        "  :param prefix: (str) Filter the video, showing only the only starting with this prefix\n",
        "  \"\"\"\n",
        "  html = []\n",
        "  for mp4 in Path(video_path).glob(\"{}*.mp4\".format(prefix)):\n",
        "      video_b64 = base64.b64encode(mp4.read_bytes())\n",
        "      html.append('''<video alt=\"{}\" autoplay \n",
        "                    loop controls style=\"height: 400px;\">\n",
        "                    <source src=\"data:video/mp4;base64,{}\" type=\"video/mp4\" />\n",
        "                </video>'''.format(mp4, video_b64.decode('ascii')))\n",
        "  ipythondisplay.display(ipythondisplay.HTML(data=\"<br>\".join(html)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LTRNUfulOGaF",
        "colab_type": "text"
      },
      "source": [
        "We will record a video using the [VecVideoRecorder](https://stable-baselines.readthedocs.io/en/master/guide/vec_envs.html#vecvideorecorder) wrapper, you will learn about those wrapper in the next notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Trag9dQpOIhx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from stable_baselines.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
        "\n",
        "def record_video(env_id, model, video_length=500, prefix='', video_folder='videos/'):\n",
        "  \"\"\"\n",
        "  :param env_id: (str)\n",
        "  :param model: (RL model)\n",
        "  :param video_length: (int)\n",
        "  :param prefix: (str)\n",
        "  :param video_folder: (str)\n",
        "  \"\"\"\n",
        "  eval_env = DummyVecEnv([lambda: gym.make(env_id)])\n",
        "  # Start the video at step=0 and record 500 steps\n",
        "  eval_env = VecVideoRecorder(eval_env, video_folder=video_folder,\n",
        "                              record_video_trigger=lambda step: step == 0, video_length=video_length,\n",
        "                              name_prefix=prefix)\n",
        "\n",
        "  obs = eval_env.reset()\n",
        "  for _ in range(video_length):\n",
        "    action, _ = model.predict(obs)\n",
        "    obs, _, _, _ = eval_env.step(action)\n",
        "\n",
        "  # Close the video recorder\n",
        "  eval_env.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KOObbeu5MMlR",
        "colab_type": "text"
      },
      "source": [
        "### Visualize trained agent\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iATu7AiyMQW2",
        "colab_type": "code",
        "outputId": "6a785eaa-e641-42be-a835-7ff322cbcd88",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "record_video('CartPole-v1', model, video_length=500, prefix='ppo2-cartpole')"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving video to  /content/videos/ppo2-cartpole-step-0-to-step-500.mp4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-n4i-fW3NojZ",
        "colab_type": "code",
        "outputId": "e6643711-afc3-49b6-e653-11e43695c0b1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 420
        }
      },
      "source": [
        "show_videos('videos', prefix='ppo2')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<video alt=\"videos/ppo2-cartpole-step-0-to-step-500.mp4\" autoplay \n",
              "                    loop controls style=\"height: 400px;\">\n",
              "                    <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
              "                </video>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Y8zg4V566qD",
        "colab_type": "text"
      },
      "source": [
        "## Bonus: Train a RL Model in One Line\n",
        "\n",
        "The policy class to use will be inferred and the environment will be automatically created. This works because both are [registered](https://stable-baselines.readthedocs.io/en/master/guide/quickstart.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iaOPfOrwWEP4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = PPO2('MlpPolicy', \"CartPole-v1\", verbose=1).learn(1000)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Se8SHBN17Fy4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WBf84jU05mgi",
        "colab_type": "text"
      },
      "source": [
        "## Train a DQN agent\n",
        "\n",
        "In the previous example, we have used PPO, which one of the many algorithms provided by stable-baselines.\n",
        "\n",
        "In the next example, we are going train a [Deep Q-Network agent (DQN)](https://stable-baselines.readthedocs.io/en/master/modules/dqn.html), and try to see possible improvements provided by its extensions (Double-DQN, Dueling-DQN, Prioritized Experience Replay).\n",
        "\n",
        "The essential point of this section is to show you how simple it is to tweak hyperparameters.\n",
        "\n",
        "The main advantage of stable-baselines is that it provides a common interface to use the algorithms, so the code will be quite similar.\n",
        "\n",
        "\n",
        "DQN paper: https://arxiv.org/abs/1312.5602\n",
        "\n",
        "Dueling DQN: https://arxiv.org/abs/1511.06581\n",
        "\n",
        "Double-Q Learning: https://arxiv.org/abs/1509.06461\n",
        "\n",
        "Prioritized Experience Replay: https://arxiv.org/abs/1511.05952"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kikNl-tT92Ae",
        "colab_type": "text"
      },
      "source": [
        "### Vanilla DQN: DQN without extensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tdLdYABz8TJx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Same as before we instantiate the agent along with the environment\n",
        "from stable_baselines import DQN\n",
        "\n",
        "# Deactivate all the DQN extensions to have the original version\n",
        "# In practice, it is recommend to have them activated\n",
        "kwargs = {'double_q': False, 'prioritized_replay': False, 'policy_kwargs': dict(dueling=False)}\n",
        "\n",
        "# Note that the MlpPolicy of DQN is different from the one of PPO\n",
        "# but stable-baselines handles that automatically if you pass a string\n",
        "dqn_model = DQN('MlpPolicy', 'CartPole-v1', verbose=1, **kwargs)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E4A_IOZ_9fzW",
        "colab_type": "code",
        "outputId": "b682bbf9-5de9-40d2-f9ff-b031598c5dd2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Random Agent, before training\n",
        "mean_reward_before_train = evaluate(dqn_model, num_episodes=100)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean reward: 9.29 Num episodes: 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4wbuvAKk9spH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Train the agent for 10000 steps\n",
        "dqn_model.learn(total_timesteps=10000, log_interval=10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QDQTdpYv9xJN",
        "colab_type": "code",
        "outputId": "363f5ed3-5bb1-4ce2-e218-10018818ecc9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Evaluate the trained agent\n",
        "mean_reward = evaluate(dqn_model, num_episodes=100)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean reward: 130.02 Num episodes: 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GFJvqsMl96l7",
        "colab_type": "text"
      },
      "source": [
        "### DQN + Prioritized Replay"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "roCSjGu69-lA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Activate only the prioritized replay\n",
        "kwargs = {'double_q': False, 'prioritized_replay': True, 'policy_kwargs': dict(dueling=False)}\n",
        "\n",
        "dqn_per_model = DQN('MlpPolicy', 'CartPole-v1', verbose=1, **kwargs)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DLnLhos5-lRm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dqn_per_model.learn(total_timesteps=10000, log_interval=10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xQjF5S_g-mFN",
        "colab_type": "code",
        "outputId": "4ce14e23-8f2b-40c1-90e1-b333d36f6997",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Evaluate the trained agent\n",
        "mean_reward = evaluate(dqn_per_model, num_episodes=100)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean reward: 110.18 Num episodes: 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Skny8MUN9_Ky",
        "colab_type": "text"
      },
      "source": [
        "### DQN + Prioritized Experience Replay + Double Q-Learning + Dueling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fDCys-Vg-yYR",
        "colab_type": "code",
        "outputId": "a3bc7511-d247-47ca-952e-53e95a1597a6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Activate all extensions\n",
        "kwargs = {'double_q': True, 'prioritized_replay': True, 'policy_kwargs': dict(dueling=True)}\n",
        "\n",
        "dqn_full_model = DQN('MlpPolicy', 'CartPole-v1', verbose=1, **kwargs)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Creating environment from the given name, wrapped in a DummyVecEnv.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "koHGB-VN-81O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dqn_full_model.learn(total_timesteps=10000, log_interval=10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6cHRULdp--nN",
        "colab_type": "code",
        "outputId": "5b2a3471-f6fe-4594-8f91-e4c62505a07a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "mean_reward = evaluate(dqn_per_model, num_episodes=100)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean reward: 110.02 Num episodes: 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n4Q9dR3UC5Zb",
        "colab_type": "text"
      },
      "source": [
        "In this particular example, the extensions does not seem to give any improvement compared to the simple DQN version.\n",
        "They are several reasons for that:\n",
        "\n",
        "1. `CartPole-v1` is a pretty simple environment\n",
        "2. We trained DQN for very few timesteps, not enough to see any difference\n",
        "3. The default hyperparameters for DQN are tuned for atari games, where the number of training timesteps is much larger (10^6) and input observations are images\n",
        "4. We have only compared one random seed per experiment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FrI6f5fWnzp-",
        "colab_type": "text"
      },
      "source": [
        "## Conclusion\n",
        "\n",
        "In this notebook we have seen:\n",
        "- how to define and train a RL model using stable baselines, it takes only one line of code ;)\n",
        "- how to use different RL algorithms and change some hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "73ji3gbNDkf7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}