From b5dab072e6ee36af5346a1e4d9729f04a5d62807 Mon Sep 17 00:00:00 2001 From: Jalaj Bhandari Date: Tue, 20 Feb 2024 15:51:40 -0800 Subject: [PATCH] Tuturial: DQN and Double DQN with network instance Summary: This simple example illustrates how users can use implementations of value based methods, specifically, DQN and Double DQN, with gym environments. In Pearl, we also allow users to pass network instance to value based methods. This example illustrates how to use this functionality in Pearl. Reviewed By: rodrigodesalvobraz Differential Revision: D53947100 fbshipit-source-id: 7b1a437e37cbb746565f0c283f1bb7905d6af137 --- .../DQN_and_DoubleDQN_example.ipynb | 539 ++++++++++++++++++ 1 file changed, 539 insertions(+) create mode 100644 tutorials/sequential_decision_making/DQN_and_DoubleDQN_example.ipynb diff --git a/tutorials/sequential_decision_making/DQN_and_DoubleDQN_example.ipynb b/tutorials/sequential_decision_making/DQN_and_DoubleDQN_example.ipynb new file mode 100644 index 00000000..0b3a141b --- /dev/null +++ b/tutorials/sequential_decision_making/DQN_and_DoubleDQN_example.ipynb @@ -0,0 +1,539 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Using DQN and Double DQN in Pearl with different neural network instantiations.\n", + "\n", + "- The purpose of this tutorial is two fold. First, it illustrates how users can use implementations of value based methods, for example, DQN and Double DQN, in Pearl. We use a simple Gym environment for illustration.\n", + "\n", + "- Second, it illustrates how users can instantiate a neural network (outside of a Pearl Agent) and pass it to different policy learners in Pearl. For both examples (DQN and Double DQN), we use an instantiation of `QValueNetworks` outside of the Pearl Agent. The default way right now is to instantiate a Q value network inside the agent's policy learner.\n", + "\n", + "- Users can also instantiate custom networks and use these with different policy learners in Pearl, but are expected to follow the general design of the\n", + "value networks/critic networks/actor networks base class. For example, for value based methods such as DQN and Double DQN, users should follow the design of the `QValueNetwork` base class." + ], + "metadata": { + "id": "6cYM7L_EbaD2" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "Kztd2SaMY7BK" + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Pearl Installation\n", + "\n", + "If you haven't installed Pearl, please make sure you install Pearl with the following cell. Otherwise, you can skip the cell below.\n", + "\n" + ], + "metadata": { + "id": "hpBKgJ3tZSKg" + } + }, + { + "cell_type": "code", + "source": [ + "# Pearl installation from github. This install also includes PyTorch, Gym and Matplotlib\n", + "\n", + "%pip uninstall Pearl -y\n", + "%rm -rf Pearl\n", + "!git clone https://github.com/facebookresearch/Pearl.git\n", + "%cd Pearl\n", + "%pip install .\n", + "%cd .." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SFOG6DepZLS1", + "outputId": "1c16659a-0329-4709-f329-0fc4031994f6" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[33mWARNING: Skipping Pearl as it is not installed.\u001b[0m\u001b[33m\n", + "\u001b[0mCloning into 'Pearl'...\n", + "remote: Enumerating objects: 5031, done.\u001b[K\n", + "remote: Counting objects: 100% (1243/1243), done.\u001b[K\n", + "remote: Compressing objects: 100% (328/328), done.\u001b[K\n", + "remote: Total 5031 (delta 1019), reused 1026 (delta 908), pack-reused 3788\u001b[K\n", + "Receiving objects: 100% (5031/5031), 13.55 MiB | 11.32 MiB/s, done.\n", + "Resolving deltas: 100% (3349/3349), done.\n", + "/content/Pearl\n", + "Processing /content/Pearl\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: gym in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (0.25.2)\n", + "Collecting gymnasium[accept-rom-license,atari,mujoco] (from Pearl==0.1.0)\n", + " Downloading gymnasium-0.29.1-py3-none-any.whl (953 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m953.9/953.9 kB\u001b[0m \u001b[31m8.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (1.25.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (3.7.1)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (1.5.3)\n", + "Collecting parameterized (from Pearl==0.1.0)\n", + " Downloading parameterized-0.9.0-py2.py3-none-any.whl (20 kB)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (2.31.0)\n", + "Collecting mujoco (from Pearl==0.1.0)\n", + " Downloading mujoco-3.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (5.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.3/5.3 MB\u001b[0m \u001b[31m17.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (2.1.0+cu121)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (0.16.0+cu121)\n", + "Requirement already satisfied: torchaudio in /usr/local/lib/python3.10/dist-packages (from Pearl==0.1.0) (2.1.0+cu121)\n", + "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gym->Pearl==0.1.0) (2.2.1)\n", + "Requirement already satisfied: gym-notices>=0.0.4 in /usr/local/lib/python3.10/dist-packages (from gym->Pearl==0.1.0) (0.0.8)\n", + "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0) (4.9.0)\n", + "Collecting farama-notifications>=0.0.1 (from gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0)\n", + " Downloading Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n", + "Requirement already satisfied: imageio>=2.14.1 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0) (2.31.6)\n", + "Collecting autorom[accept-rom-license]~=0.4.2 (from gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0)\n", + " Downloading AutoROM-0.4.2-py3-none-any.whl (16 kB)\n", + "Collecting shimmy[atari]<1.0,>=0.1.0 (from gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0)\n", + " Downloading Shimmy-0.2.1-py3-none-any.whl (25 kB)\n", + "Requirement already satisfied: absl-py in /usr/local/lib/python3.10/dist-packages (from mujoco->Pearl==0.1.0) (1.4.0)\n", + "Requirement already satisfied: etils[epath] in /usr/local/lib/python3.10/dist-packages (from mujoco->Pearl==0.1.0) (1.6.0)\n", + "Collecting glfw (from mujoco->Pearl==0.1.0)\n", + " Downloading glfw-2.6.5-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38-none-manylinux2014_x86_64.whl (211 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.8/211.8 kB\u001b[0m \u001b[31m17.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pyopengl in /usr/local/lib/python3.10/dist-packages (from mujoco->Pearl==0.1.0) (3.1.7)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (1.2.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (4.48.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (23.2)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (3.1.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->Pearl==0.1.0) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->Pearl==0.1.0) (2023.4)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->Pearl==0.1.0) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->Pearl==0.1.0) (3.6)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->Pearl==0.1.0) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->Pearl==0.1.0) (2024.2.2)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch->Pearl==0.1.0) (3.13.1)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->Pearl==0.1.0) (1.12)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->Pearl==0.1.0) (3.2.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->Pearl==0.1.0) (3.1.3)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch->Pearl==0.1.0) (2023.6.0)\n", + "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch->Pearl==0.1.0) (2.1.0)\n", + "Requirement already satisfied: click in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0) (8.1.7)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0) (4.66.2)\n", + "Collecting AutoROM.accept-rom-license (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0)\n", + " Downloading AutoROM.accept-rom-license-0.6.1.tar.gz (434 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m434.7/434.7 kB\u001b[0m \u001b[31m20.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->Pearl==0.1.0) (1.16.0)\n", + "Collecting ale-py~=0.8.1 (from shimmy[atari]<1.0,>=0.1.0->gymnasium[accept-rom-license,atari,mujoco]->Pearl==0.1.0)\n", + " Downloading ale_py-0.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m32.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: importlib_resources in /usr/local/lib/python3.10/dist-packages (from etils[epath]->mujoco->Pearl==0.1.0) (6.1.1)\n", + "Requirement already satisfied: zipp in /usr/local/lib/python3.10/dist-packages (from etils[epath]->mujoco->Pearl==0.1.0) (3.17.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->Pearl==0.1.0) (2.1.5)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->Pearl==0.1.0) (1.3.0)\n", + "Building wheels for collected packages: Pearl, AutoROM.accept-rom-license\n", + " Building wheel for Pearl (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for Pearl: filename=Pearl-0.1.0-py3-none-any.whl size=202522 sha256=38dea56d8399dda69b596bf1b2ee9ff594b5eebb56e96926e7b78fabfd5765be\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-40t3u4sz/wheels/83/80/1d/d9211ba70ee392341daf21a07252739e0cb2af9f95439a28cd\n", + " Building wheel for AutoROM.accept-rom-license (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for AutoROM.accept-rom-license: filename=AutoROM.accept_rom_license-0.6.1-py3-none-any.whl size=446660 sha256=2fb88d1daa3f2880bdf8d5eabc8b3fca8cea72153ac36d375d9b8b4723ec9a79\n", + " Stored in directory: /root/.cache/pip/wheels/6b/1b/ef/a43ff1a2f1736d5711faa1ba4c1f61be1131b8899e6a057811\n", + "Successfully built Pearl AutoROM.accept-rom-license\n", + "Installing collected packages: glfw, farama-notifications, parameterized, gymnasium, ale-py, shimmy, AutoROM.accept-rom-license, autorom, mujoco, Pearl\n", + "Successfully installed AutoROM.accept-rom-license-0.6.1 Pearl-0.1.0 ale-py-0.8.1 autorom-0.4.2 farama-notifications-0.0.4 glfw-2.6.5 gymnasium-0.29.1 mujoco-3.1.2 parameterized-0.9.0 shimmy-0.2.1\n", + "/content\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Import Modules" + ], + "metadata": { + "id": "nmM2svESZlWP" + } + }, + { + "cell_type": "code", + "source": [ + "import gymnasium as gym\n", + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from typing import List\n", + "\n", + "from pearl.neural_networks.sequential_decision_making.q_value_networks import VanillaQValueNetwork, QuantileQValueNetwork\n", + "from pearl.utils.functional_utils.experimentation.set_seed import set_seed\n", + "from pearl.action_representation_modules.identity_action_representation_module import IdentityActionRepresentationModule\n", + "from pearl.policy_learners.sequential_decision_making.deep_q_learning import DeepQLearning\n", + "from pearl.policy_learners.sequential_decision_making.double_dqn import DoubleDQN\n", + "from pearl.replay_buffers.sequential_decision_making.fifo_off_policy_replay_buffer import FIFOOffPolicyReplayBuffer\n", + "from pearl.utils.functional_utils.train_and_eval.online_learning import online_learning\n", + "from pearl.pearl_agent import PearlAgent\n", + "from pearl.utils.instantiations.environments.gym_environment import GymEnvironment\n", + "from pearl.action_representation_modules.one_hot_action_representation_module import (\n", + " OneHotActionTensorRepresentationModule,\n", + ")\n", + "from pearl.api.environment import Environment\n", + "\n", + "set_seed(0)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cTn82t7IZbUz", + "outputId": "40fd0c11-721b-41d2-e44e-a50835700571" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Instantiate a simple Q value network\n", + "\n", + "- In Pearl, Q value networks assume inputs in the form of (state representation, action representation) and output estimated Q(s,a) through the `get_q_values` function.\n" + ], + "metadata": { + "id": "tf_H26pQZySE" + } + }, + { + "cell_type": "code", + "source": [ + "env = GymEnvironment(\"CartPole-v1\")\n", + "num_actions = env.action_space.n\n", + "\n", + "# VanillaQValueNetwork class uses a simple mlp for approximating the Q values.\n", + "# - Input dimension of the mlp = (state_dim + action_dim)\n", + "# - Size of the intermediate layers are specified as list of `hidden_dims`.\n", + "hidden_dims = [64, 64]\n", + "\n", + "\n", + "# We will be using a one hot representation for representing actions. So take action_dim = num_actions.\n", + "Q_value_network = VanillaQValueNetwork(state_dim=env.observation_space.shape[0], # dimension of the state representation\n", + " action_dim=num_actions, # dimension of the action representation\n", + " hidden_dims=hidden_dims, # dimensions of the intermediate layers\n", + " output_dim=1) # set to 1 (Q values are scalars)" + ], + "metadata": { + "id": "TVymL7KuamSC" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Example 1: Set up a simple DQN agent" + ], + "metadata": { + "id": "mS_hQi0HdeJE" + } + }, + { + "cell_type": "code", + "source": [ + "# Set the action representation module\n", + "action_representation_module=OneHotActionTensorRepresentationModule(\n", + " max_number_actions=num_actions\n", + ")\n", + "\n", + "\n", + "# Instead of using the 'network_type' argument, use the 'network_instance' argument.\n", + "# Pass Q_value_network as the `network_instance` to the `DeepQLearning` policy learner.\n", + "DQNagent = PearlAgent(\n", + " policy_learner=DeepQLearning(\n", + " state_dim=env.observation_space.shape[0],\n", + " action_space=env.action_space,\n", + " batch_size=64,\n", + " training_rounds=10,\n", + " soft_update_tau=0.75,\n", + " network_instance=Q_value_network, # pass an instance of Q value network to the policy learner.\n", + " action_representation_module=OneHotActionTensorRepresentationModule(\n", + " max_number_actions=num_actions\n", + " ),\n", + " ),\n", + " replay_buffer=FIFOOffPolicyReplayBuffer(10_000),\n", + ")" + ], + "metadata": { + "id": "VzdR0nQ3ddCP" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Online interaction and learning" + ], + "metadata": { + "id": "dOxhwr9vdwdD" + } + }, + { + "cell_type": "code", + "source": [ + "# The online learning function in Pearl implements environment interaction and learning\n", + "# and returns a dictionary with episodic returns\n", + "\n", + "info = online_learning(\n", + " agent=DQNagent,\n", + " env=env,\n", + " number_of_episodes=200,\n", + " print_every_x_episodes=20, # print returns after every 10 episdoes\n", + " learn_after_episode=True, # instead of updating after every environment interaction, Q networks are updates at the end of each episode\n", + " seed=0\n", + ")\n", + "\n", + "torch.save(info[\"return\"], \"DQN-return.pt\") # info[\"return\"] refers to the episodic returns\n", + "plt.plot(np.arange(len(info[\"return\"])), info[\"return\"], label=\"DQN\")\n", + "plt.title(\"Episodic returns\")\n", + "plt.xlabel(\"Episode\")\n", + "plt.ylabel(\"Return\")\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 828 + }, + "id": "RwvEhtr9dul2", + "outputId": "5a5194a8-7465-40d3-8978-10fab94784dd" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "episode 20, step 189, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 13.0\n", + "episode 40, step 397, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 10.0\n", + "episode 60, step 2276, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 47.0\n", + "episode 80, step 6046, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 258.0\n", + "episode 100, step 8598, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 410.0\n", + "episode 120, step 14451, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n", + "episode 140, step 23523, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n", + "episode 160, step 31382, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 102.0\n", + "episode 180, step 39593, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n", + "episode 200, step 47571, agent=PearlAgent with DeepQLearning, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Example 2: Set up a simple Double DQN agent" + ], + "metadata": { + "id": "nYcmco2AeDjZ" + } + }, + { + "cell_type": "code", + "source": [ + "# Set up a different instance of a Q value network.\n", + "\n", + "# We will be using a one hot representation for representing actions. So take action_dim = num_actions.\n", + "Q_network_DoubleDQN = VanillaQValueNetwork(state_dim=env.observation_space.shape[0], # dimension of the state representation\n", + " action_dim=num_actions, # dimension of the action representation\n", + " hidden_dims=hidden_dims, # dimensions of the intermediate layers\n", + " output_dim=1) # set to 1 (Q values are scalars)\n" + ], + "metadata": { + "id": "z8KLVeJ9gVat" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Set the action representation module\n", + "action_representation_module=OneHotActionTensorRepresentationModule(\n", + " max_number_actions=num_actions\n", + ")\n", + "\n", + "# Instead of using the 'network_type' argument, use the 'network_instance' argument.\n", + "# Pass Q_value_network as the `network_instance` to the `DoubleDQN` policy learner.\n", + "DoubleDQNagent = PearlAgent(\n", + " policy_learner=DoubleDQN(\n", + " state_dim=env.observation_space.shape[0],\n", + " action_space=env.action_space,\n", + " batch_size=64,\n", + " training_rounds=10,\n", + " soft_update_tau=0.75,\n", + " network_instance=Q_network_DoubleDQN, # pass an instance of Q value network to the policy learner.\n", + " action_representation_module=OneHotActionTensorRepresentationModule(\n", + " max_number_actions=num_actions\n", + " ),\n", + " ),\n", + " replay_buffer=FIFOOffPolicyReplayBuffer(10_000),\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "L7JU0jqPeKt1", + "outputId": "7a5527b0-4101-423e-b1ff-d3ceffb46a46" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Online interaction and learning" + ], + "metadata": { + "id": "G_XHwamtfBuE" + } + }, + { + "cell_type": "code", + "source": [ + "# The online learning function in Pearl implements environment interaction and learning\n", + "# and returns a dictionary with episodic returns\n", + "\n", + "info_DoubleDQN = online_learning(\n", + " agent=DoubleDQNagent,\n", + " env=env,\n", + " number_of_episodes=200,\n", + " print_every_x_episodes=20, # print returns after every 10 episdoes\n", + " learn_after_episode=True, # instead of updating after every environment interaction, Q networks are updates at the end of each episode\n", + " seed=0\n", + ")\n", + "\n", + "torch.save(info_DoubleDQN[\"return\"], \"DoubleDQN-return.pt\") # info[\"return\"] refers to the episodic returns\n", + "plt.plot(np.arange(len(info_DoubleDQN[\"return\"])), info_DoubleDQN[\"return\"], label=\"DoubleDQN\")\n", + "plt.title(\"Episodic returns\")\n", + "plt.xlabel(\"Episode\")\n", + "plt.ylabel(\"Return\")\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 828 + }, + "id": "g9GAR6wQfMg_", + "outputId": "2c74ace5-8d03-4880-97bc-2d2e318f99db" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "episode 20, step 189, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 13.0\n", + "episode 40, step 388, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 12.0\n", + "episode 60, step 2141, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 65.0\n", + "episode 80, step 6395, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 430.0\n", + "episode 100, step 14192, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n", + "episode 120, step 22989, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n", + "episode 140, step 30604, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n", + "episode 160, step 39663, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n", + "episode 180, step 45132, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 105.0\n", + "episode 200, step 50190, agent=PearlAgent with DoubleDQN, FIFOOffPolicyReplayBuffer, env=CartPole-v1\n", + "return: 500.0\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file