diff --git a/projects/ReinforcementLearning/lunar_lander.ipynb b/projects/ReinforcementLearning/lunar_lander.ipynb index 30d72f76f..80b6eda54 100644 --- a/projects/ReinforcementLearning/lunar_lander.ipynb +++ b/projects/ReinforcementLearning/lunar_lander.ipynb @@ -1,1225 +1,1300 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "execution": {}, - "id": "view-in-github" - }, - "source": [ - "\"Open   \"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "# Performance Analysis of DQN Algorithm on the Lunar Lander task\n", - "\n", - "**By Neuromatch Academy**\n", - "\n", - "__Content creators:__ Raghuram Bharadwaj Diddigi, Geraud Nangue Tasse, Yamil Vidal, Sanjukta Krishnagopal, Sara Rajaee\n", - "\n", - "__Content editors:__ Shaonan Wang, Spiros Chavlis" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "---\n", - "# Objective\n", - "\n", - "In this project, the objective is to analyze the performance of the Deep Q-Learning algorithm on an exciting task- Lunar Lander. Before we describe the task, let us focus on two keywords here - analysis and performance. What exactly do we mean by these keywords in the context of Reinforcement Learning (RL)?" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "---\n", - "# Setup" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "cellView": "form", - "execution": {} - }, - "outputs": [], - "source": [ - "# @title Update/Upgrade the system and install libs\n", - "!apt-get update > /dev/null 2>&1\n", - "!apt-get install -y xvfb python-opengl ffmpeg > /dev/null 2>&1\n", - "!apt-get install -y swig build-essential python-dev python3-dev > /dev/null 2>&1\n", - "!apt-get install x11-utils > /dev/null 2>&1\n", - "!apt-get install xvfb > /dev/null 2>&1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "cellView": "form", - "execution": {} - }, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.0/14.0 MB\u001b[0m \u001b[31m28.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h" - ] - } - ], - "source": [ - "# @title Install dependencies\n", - "!pip install rarfile --quiet\n", - "!pip install stable-baselines3[extra] --quiet\n", - "!pip install ale-py --quiet\n", - "!pip install gym[box2d] --quiet\n", - "!pip install pyvirtualdisplay --quiet\n", - "!pip install pyglet --quiet\n", - "!pip install pygame --quiet\n", - "!pip install minigrid --quiet\n", - "!pip install -q swig --quiet\n", - "!pip install -q gymnasium[box2d] --quiet\n", - "!pip install 'minigrid<=2.1.1' --quiet\n", - "!pip3 install box2d-py --quiet" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "sgIXqXYCDBuR" + }, + "source": [ + "# Performance Analysis of DQN Algorithm on the Lunar Lander task\n", + "\n", + "**By Neuromatch Academy**\n", + "\n", + "__Content creators:__ Raghuram Bharadwaj Diddigi, Geraud Nangue Tasse, Yamil Vidal, Sanjukta Krishnagopal, Sara Rajaee\n", + "\n", + "__Content editors:__ Shaonan Wang, Spiros Chavlis" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/tensorflow/python/framework/dtypes.py:35: DeprecationWarning: ml_dtypes.float8_e4m3b11 is deprecated. Use ml_dtypes.float8_e4m3b11fnuz\n", - " from tensorflow.tsl.python.lib.core import pywrap_ml_dtypes\n" - ] - } - ], - "source": [ - "# Imports\n", - "import io\n", - "import os\n", - "import glob\n", - "import torch\n", - "import base64\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import sys\n", - "import gymnasium\n", - "sys.modules[\"gym\"] = gymnasium\n", - "\n", - "import stable_baselines3\n", - "from stable_baselines3 import DQN\n", - "from stable_baselines3.common.results_plotter import ts2xy, load_results\n", - "from stable_baselines3.common.callbacks import EvalCallback\n", - "from stable_baselines3.common.env_util import make_atari_env\n", - "\n", - "import gymnasium as gym\n", - "from gym import spaces\n", - "from gym.envs.box2d.lunar_lander import *\n", - "from gym.wrappers.monitoring.video_recorder import VideoRecorder" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "cellView": "form", - "execution": {} - }, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "AKlrTCmFDBuS" + }, + "source": [ + "---\n", + "# Objective\n", + "\n", + "In this project, the objective is to analyze the performance of the Deep Q-Learning algorithm on an exciting task- Lunar Lander. Before we describe the task, let us focus on two keywords here - analysis and performance. What exactly do we mean by these keywords in the context of Reinforcement Learning (RL)?" + ] + }, { - "name": "stderr", - "output_type": "stream", - "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" - ] - } - ], - "source": [ - "# @title Play Video function\n", - "from IPython.display import HTML\n", - "from base64 import b64encode\n", - "from pyvirtualdisplay import Display\n", - "\n", - "# create the directory to store the video(s)\n", - "os.makedirs(\"./video\", exist_ok=True)\n", - "\n", - "display = Display(visible=False, size=(1400, 900))\n", - "_ = display.start()\n", - "\n", - "\"\"\"\n", - "Utility functions to enable video recording of gym environment\n", - "and displaying it.\n", - "To enable video, just do \"env = wrap_env(env)\"\"\n", - "\"\"\"\n", - "def render_mp4(videopath: str) -> str:\n", - " \"\"\"\n", - " Gets a string containing a b4-encoded version of the MP4 video\n", - " at the specified path.\n", - " \"\"\"\n", - " mp4 = open(videopath, 'rb').read()\n", - " base64_encoded_mp4 = b64encode(mp4).decode()\n", - " return f''" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "---\n", - "# Introduction\n", - "\n", - "In a standard RL setting, an agent learns optimal behavior from an environment through a feedback mechanism to maximize a given objective. Many algorithms have been proposed in the RL literature that an agent can apply to learn the optimal behavior. One such popular algorithm is the Deep Q-Network (DQN). This algorithm makes use of deep neural networks to compute optimal actions. In this project, your goal is to understand the effect of the number of neural network layers on the algorithm's performance. The performance of the algorithm can be evaluated through two metrics - Speed and Stability.\n", - "\n", - "**Speed:** How fast the algorithm reaches the maximum possible reward.\n", - "\n", - "**Stability** In some applications (especially when online learning is involved), along with speed, stability of the algorithm, i.e., minimal fluctuations in performance, is equally important.\n", - "\n", - "In this project, you should investigate the following question:\n", - "\n", - "**What is the impact of number of neural network layers on speed and stability of the algorithm?**\n", - "\n", - "You do not have to write the DQN code from scratch. We have provided a basic implementation of the DQN algorithm. You only have to tune the hyperparameters (neural network size, learning rate, etc), observe the performance, and analyze. More details on this are provided below.\n", - "\n", - "Now, let us discuss the RL task we have chosen, i.e., Lunar Lander. This task consists of the lander and a landing pad marked by two flags. The episode starts with the lander moving downwards due to gravity. The objective is to land safely using different engines available on the lander with zero speed on the landing pad as quickly and fuel efficient as possible. Reward for moving from the top of the screen and landing on landing pad with zero speed is between 100 to 140 points. Each leg ground contact yields a reward of 10 points. Firing main engine leads to a reward of -0.3 points in each frame. Firing the side engine leads to a reward of -0.03 points in each frame. An additional reward of -100 or +100 points is received if the lander crashes or comes to rest respectively which also leads to end of the episode.\n", - "\n", - "The input state of the Lunar Lander consists of following components:\n", - "\n", - " 1. Horizontal Position\n", - " 2. Vertical Position\n", - " 3. Horizontal Velocity\n", - " 4. Vertical Velocity\n", - " 5. Angle\n", - " 6. Angular Velocity\n", - " 7. Left Leg Contact\n", - " 8. Right Leg Contact\n", - "\n", - "The actions of the agents are:\n", - " 1. Do Nothing\n", - " 2. Fire Main Engine\n", - " 3. Fire Left Engine\n", - " 4. Fire Right Engine\n", - "\n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "---\n", - "# Basic DQN Implementation\n", - "\n", - "We will now implement the DQN algorithm using the existing code base. We encourage you to understand this example and re-use it in an application/project of your choice!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Now, let us set some hyperparameters for our algorithm. This is the only part you would play around with, to solve the first part of the project." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "x5XKBDyYDBuS" + }, + "source": [ + "---\n", + "# Setup" + ] + }, { - "name": "stderr", - "output_type": "stream", - "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" - ] - } - ], - "source": [ - "nn_layers = [64, 64] # This is the configuration of your neural network. Currently, we have two layers, each consisting of 64 neurons.\n", - " # If you want three layers with 64 neurons each, set the value to [64,64,64] and so on.\n", - "\n", - "learning_rate = 0.001 # This is the step-size with which the gradient descent is carried out.\n", - " # Tip: Use smaller step-sizes for larger networks." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Now, let us setup our model and the DQN algorithm." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "log_dir = \"/tmp/gym/\"\n", - "os.makedirs(log_dir, exist_ok=True)\n", - "\n", - "# Create environment\n", - "env_name = 'LunarLander-v2'\n", - "env = gym.make(env_name)\n", - "# You can also load other environments like cartpole, MountainCar, Acrobot.\n", - "# Refer to https://gym.openai.com/docs/ for descriptions.\n", - "\n", - "# For example, if you would like to load Cartpole,\n", - "# just replace the above statement with \"env = gym.make('CartPole-v1')\".\n", - "\n", - "env = stable_baselines3.common.monitor.Monitor(env, log_dir )\n", - "\n", - "callback = EvalCallback(env, log_path=log_dir, deterministic=True) # For evaluating the performance of the agent periodically and logging the results.\n", - "policy_kwargs = dict(activation_fn=torch.nn.ReLU,\n", - " net_arch=nn_layers)\n", - "model = DQN(\"MlpPolicy\", env,policy_kwargs = policy_kwargs,\n", - " learning_rate=learning_rate,\n", - " batch_size=1, # for simplicity, we are not doing batch update.\n", - " buffer_size=1, # size of experience of replay buffer. Set to 1 as batch update is not done\n", - " learning_starts=1, # learning starts immediately!\n", - " gamma=0.99, # discount facto. range is between 0 and 1.\n", - " tau = 1, # the soft update coefficient for updating the target network\n", - " target_update_interval=1, # update the target network immediately.\n", - " train_freq=(1,\"step\"), # train the network at every step.\n", - " max_grad_norm = 10, # the maximum value for the gradient clipping\n", - " exploration_initial_eps = 1, # initial value of random action probability\n", - " exploration_fraction = 0.5, # fraction of entire training period over which the exploration rate is reduced\n", - " gradient_steps = 1, # number of gradient steps\n", - " seed = 1, # seed for the pseudo random generators\n", - " verbose=0) # Set verbose to 1 to observe training logs. We encourage you to set the verbose to 1.\n", - "\n", - "# You can also experiment with other RL algorithms like A2C, PPO, DDPG etc.\n", - "# Refer to https://stable-baselines3.readthedocs.io/en/master/guide/examples.html\n", - "# for documentation. For example, if you would like to run DDPG, just replace \"DQN\" above with \"DDPG\"." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Before we train the model, let us look at an instance of Lunar Lander **before training**. \n", - "\n", - "**Note:** The following code for rendering the video is taken from [here](https://colab.research.google.com/github/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_12_01_ai_gym.ipynb#scrollTo=T9RpF49oOsZj)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": { + "cellView": "form", + "execution": {}, + "id": "WsHayfTHDBuS" + }, + "outputs": [], + "source": [ + "# @title Update/Upgrade the system and install libs\n", + "!apt-get update > /dev/null 2>&1\n", + "!apt-get install -y xvfb python-opengl ffmpeg > /dev/null 2>&1\n", + "!apt-get install -y swig build-essential python-dev python3-dev > /dev/null 2>&1\n", + "!apt-get install x11-utils > /dev/null 2>&1\n", + "!apt-get install xvfb > /dev/null 2>&1" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "State shape: (8,)\n", - "Number of actions: 4\n" - ] + "cell_type": "code", + "execution_count": 21, + "metadata": { + "execution": {}, + "id": "6fooEJQSDBuT", + "outputId": "73371ac6-9d7e-42e4-acee-5a0636eec589", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: swig in /usr/local/lib/python3.10/dist-packages (4.2.1)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.0/14.0 MB\u001b[0m \u001b[31m61.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "# @title Install dependencies\n", + "!pip install rarfile --quiet\n", + "!pip install stable-baselines3[extra] --quiet\n", + "!pip install ale-py --quiet\n", + "!pip install swig\n", + "!pip install gym[box2d] --quiet\n", + "!pip install pyvirtualdisplay --quiet\n", + "!pip install pyglet --quiet\n", + "!pip install pygame --quiet\n", + "!pip install minigrid --quiet\n", + "!pip install -q swig --quiet\n", + "!pip install -q gymnasium[box2d] --quiet\n", + "!pip install 'minigrid<=2.1.1' --quiet\n", + "!pip3 install box2d-py --quiet" + ] }, { - "name": "stderr", - "output_type": "stream", - "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" - ] - } - ], - "source": [ - "env_name = 'LunarLander-v2'\n", - "env = gym.make(env_name)\n", - "print('State shape: ', env.observation_space.shape)\n", - "print('Number of actions: ', env.action_space.n)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": {}, + "id": "nA2Y9HGUDBuT" + }, + "outputs": [], + "source": [ + "# Imports\n", + "import io\n", + "import os\n", + "import glob\n", + "import torch\n", + "import base64\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import sys\n", + "import gymnasium\n", + "sys.modules[\"gym\"] = gymnasium\n", + "\n", + "import stable_baselines3\n", + "from stable_baselines3 import DQN\n", + "from stable_baselines3.common.results_plotter import ts2xy, load_results\n", + "from stable_baselines3.common.callbacks import EvalCallback\n", + "from stable_baselines3.common.env_util import make_atari_env\n", + "\n", + "import gymnasium as gym\n", + "from gym import spaces\n", + "from gym.envs.box2d.lunar_lander import *\n", + "from gym.wrappers.monitoring.video_recorder import VideoRecorder" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/gym/wrappers/monitoring/video_recorder.py:101: DeprecationWarning: \u001b[33mWARN: is marked as deprecated and will be removed in the future.\u001b[0m\n", - " logger.deprecation(\n" - ] + "cell_type": "code", + "execution_count": 4, + "metadata": { + "cellView": "form", + "execution": {}, + "id": "_M-76WwDDBuT", + "outputId": "74dde974-1a97-4be7-e7ce-6a2964b602e2", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "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" + ] + } + ], + "source": [ + "# @title Play Video function\n", + "from IPython.display import HTML\n", + "from base64 import b64encode\n", + "from pyvirtualdisplay import Display\n", + "\n", + "# create the directory to store the video(s)\n", + "os.makedirs(\"./video\", exist_ok=True)\n", + "\n", + "display = Display(visible=False, size=(1400, 900))\n", + "_ = display.start()\n", + "\n", + "\"\"\"\n", + "Utility functions to enable video recording of gym environment\n", + "and displaying it.\n", + "To enable video, just do \"env = wrap_env(env)\"\"\n", + "\"\"\"\n", + "def render_mp4(videopath: str) -> str:\n", + " \"\"\"\n", + " Gets a string containing a b4-encoded version of the MP4 video\n", + " at the specified path.\n", + " \"\"\"\n", + " mp4 = open(videopath, 'rb').read()\n", + " base64_encoded_mp4 = b64encode(mp4).decode()\n", + " return f''" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Total reward: -597.0358279244006\n" - ] + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "UJnBSc5KDBuU" + }, + "source": [ + "---\n", + "# Introduction\n", + "\n", + "In a standard RL setting, an agent learns optimal behavior from an environment through a feedback mechanism to maximize a given objective. Many algorithms have been proposed in the RL literature that an agent can apply to learn the optimal behavior. One such popular algorithm is the Deep Q-Network (DQN). This algorithm makes use of deep neural networks to compute optimal actions. In this project, your goal is to understand the effect of the number of neural network layers on the algorithm's performance. The performance of the algorithm can be evaluated through two metrics - Speed and Stability.\n", + "\n", + "**Speed:** How fast the algorithm reaches the maximum possible reward.\n", + "\n", + "**Stability** In some applications (especially when online learning is involved), along with speed, stability of the algorithm, i.e., minimal fluctuations in performance, is equally important.\n", + "\n", + "In this project, you should investigate the following question:\n", + "\n", + "**What is the impact of number of neural network layers on speed and stability of the algorithm?**\n", + "\n", + "You do not have to write the DQN code from scratch. We have provided a basic implementation of the DQN algorithm. You only have to tune the hyperparameters (neural network size, learning rate, etc), observe the performance, and analyze. More details on this are provided below.\n", + "\n", + "Now, let us discuss the RL task we have chosen, i.e., Lunar Lander. This task consists of the lander and a landing pad marked by two flags. The episode starts with the lander moving downwards due to gravity. The objective is to land safely using different engines available on the lander with zero speed on the landing pad as quickly and fuel efficient as possible. Reward for moving from the top of the screen and landing on landing pad with zero speed is between 100 to 140 points. Each leg ground contact yields a reward of 10 points. Firing main engine leads to a reward of -0.3 points in each frame. Firing the side engine leads to a reward of -0.03 points in each frame. An additional reward of -100 or +100 points is received if the lander crashes or comes to rest respectively which also leads to end of the episode.\n", + "\n", + "The input state of the Lunar Lander consists of following components:\n", + "\n", + " 1. Horizontal Position\n", + " 2. Vertical Position\n", + " 3. Horizontal Velocity\n", + " 4. Vertical Velocity\n", + " 5. Angle\n", + " 6. Angular Velocity\n", + " 7. Left Leg Contact\n", + " 8. Right Leg Contact\n", + "\n", + "The actions of the agents are:\n", + " 1. Do Nothing\n", + " 2. Fire Main Engine\n", + " 3. Fire Left Engine\n", + " 4. Fire Right Engine\n", + "\n", + "\n", + "" + ] }, { - "data": { - "text/html": [ - "" + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "XuSpVWuGDBuU" + }, + "source": [ + "---\n", + "# Basic DQN Implementation\n", + "\n", + "We will now implement the DQN algorithm using the existing code base. We encourage you to understand this example and re-use it in an application/project of your choice!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "dYwJRvx-DBuV" + }, + "source": [ + "Now, let us set some hyperparameters for our algorithm. This is the only part you would play around with, to solve the first part of the project." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": {}, + "id": "MvWRAJiSDBuV", + "outputId": "23422e4b-fa32-4edd-d283-31b62668d30e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "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" + ] + } ], - "text/plain": [ - "" + "source": [ + "nn_layers = [64, 64] # This is the configuration of your neural network. Currently, we have two layers, each consisting of 64 neurons.\n", + " # If you want three layers with 64 neurons each, set the value to [64,64,64] and so on.\n", + "\n", + "learning_rate = 0.001 # This is the step-size with which the gradient descent is carried out.\n", + " # Tip: Use smaller step-sizes for larger networks." ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "env = gym.make(env_name, render_mode=\"rgb_array\")\n", - "vid = VideoRecorder(env, path=f\"video/{env_name}_pretraining.mp4\")\n", - "observation = env.reset()[0]\n", - "\n", - "total_reward = 0\n", - "done = False\n", - "while not done:\n", - " frame = env.render()\n", - " vid.capture_frame()\n", - " action, states = model.predict(observation, deterministic=True)\n", - " observation, reward, done, info, _ = env.step(action)\n", - " total_reward += reward\n", - "vid.close()\n", - "env.close()\n", - "print(f\"\\nTotal reward: {total_reward}\")\n", - "\n", - "# show video\n", - "html = render_mp4(f\"video/{env_name}_pretraining.mp4\")\n", - "HTML(html)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "From the video above, we see that the lander has crashed!\n", - "It is now the time for training!\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "EHLx2d5xDBuV" + }, + "source": [ + "Now, let us setup our model and the DQN algorithm." + ] + }, { - "name": "stderr", - "output_type": "stream", - "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": "code", + "execution_count": 6, + "metadata": { + "execution": {}, + "id": "4PzeDS2dDBuV" + }, + "outputs": [], + "source": [ + "log_dir = \"/tmp/gym/\"\n", + "os.makedirs(log_dir, exist_ok=True)\n", + "\n", + "# Create environment\n", + "env_name = 'LunarLander-v2'\n", + "env = gym.make(env_name)\n", + "# You can also load other environments like cartpole, MountainCar, Acrobot.\n", + "# Refer to https://gym.openai.com/docs/ for descriptions.\n", + "\n", + "# For example, if you would like to load Cartpole,\n", + "# just replace the above statement with \"env = gym.make('CartPole-v1')\".\n", + "\n", + "env = stable_baselines3.common.monitor.Monitor(env, log_dir )\n", + "\n", + "callback = EvalCallback(env, log_path=log_dir, deterministic=True) # For evaluating the performance of the agent periodically and logging the results.\n", + "policy_kwargs = dict(activation_fn=torch.nn.ReLU,\n", + " net_arch=nn_layers)\n", + "model = DQN(\"MlpPolicy\", env,policy_kwargs = policy_kwargs,\n", + " learning_rate=learning_rate,\n", + " batch_size=1, # for simplicity, we are not doing batch update.\n", + " buffer_size=1, # size of experience of replay buffer. Set to 1 as batch update is not done\n", + " learning_starts=1, # learning starts immediately!\n", + " gamma=0.99, # discount facto. range is between 0 and 1.\n", + " tau = 1, # the soft update coefficient for updating the target network\n", + " target_update_interval=1, # update the target network immediately.\n", + " train_freq=(1,\"step\"), # train the network at every step.\n", + " max_grad_norm = 10, # the maximum value for the gradient clipping\n", + " exploration_initial_eps = 1, # initial value of random action probability\n", + " exploration_fraction = 0.5, # fraction of entire training period over which the exploration rate is reduced\n", + " gradient_steps = 1, # number of gradient steps\n", + " seed = 1, # seed for the pseudo random generators\n", + " verbose=0) # Set verbose to 1 to observe training logs. We encourage you to set the verbose to 1.\n", + "\n", + "# You can also experiment with other RL algorithms like A2C, PPO, DDPG etc.\n", + "# Refer to https://stable-baselines3.readthedocs.io/en/master/guide/examples.html\n", + "# for documentation. For example, if you would like to run DDPG, just replace \"DQN\" above with \"DDPG\"." + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Eval num_timesteps=10000, episode_reward=-420.98 +/- 27.22\n", - "Episode length: 151.80 +/- 30.46\n", - "New best mean reward!\n", - "Eval num_timesteps=20000, episode_reward=-561.62 +/- 27.61\n", - "Episode length: 878.80 +/- 72.71\n", - "Eval num_timesteps=30000, episode_reward=-249.88 +/- 48.31\n", - "Episode length: 240.00 +/- 51.61\n", - "New best mean reward!\n", - "Eval num_timesteps=40000, episode_reward=-161.24 +/- 24.32\n", - "Episode length: 338.20 +/- 107.08\n", - "New best mean reward!\n", - "Eval num_timesteps=50000, episode_reward=160.32 +/- 108.81\n", - "Episode length: 241.20 +/- 55.82\n", - "New best mean reward!\n", - "Eval num_timesteps=60000, episode_reward=190.88 +/- 14.49\n", - "Episode length: 646.80 +/- 65.03\n", - "New best mean reward!\n", - "Eval num_timesteps=70000, episode_reward=67.05 +/- 92.04\n", - "Episode length: 139.80 +/- 35.46\n", - "Eval num_timesteps=80000, episode_reward=267.52 +/- 20.00\n", - "Episode length: 321.60 +/- 31.12\n", - "New best mean reward!\n", - "Eval num_timesteps=90000, episode_reward=67.08 +/- 126.76\n", - "Episode length: 536.00 +/- 257.21\n", - "Eval num_timesteps=100000, episode_reward=259.59 +/- 13.39\n", - "Episode length: 339.80 +/- 19.18\n" - ] + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "1FIshtazDBuW" + }, + "source": [ + "Before we train the model, let us look at an instance of Lunar Lander **before training**. \n", + "\n", + "**Note:** The following code for rendering the video is taken from [here](https://colab.research.google.com/github/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_12_01_ai_gym.ipynb#scrollTo=T9RpF49oOsZj)." + ] }, { - "data": { - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": {}, + "id": "SyD6VwDhDBuW", + "outputId": "1689b33b-720e-4d7f-d8e8-56cabfb398f1", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "State shape: (8,)\n", + "Number of actions: 4\n" + ] + }, + { + "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" + ] + } + ], + "source": [ + "env_name = 'LunarLander-v2'\n", + "env = gym.make(env_name)\n", + "print('State shape: ', env.observation_space.shape)\n", + "print('Number of actions: ', env.action_space.n)" ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.learn(total_timesteps=100000, log_interval=10, callback=callback)\n", - "# The performance of the training will be printed every 10 episodes. Change it to 1, if you wish to\n", - "# view the performance at every training episode." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "The training takes time. We encourage you to analyze the output logs (set verbose to 1 to print the output logs). The main component of the logs that you should track is \"ep_rew_mean\" (mean of episode rewards). As the training proceeds, the value of \"ep_rew_mean\" should increase. The improvement need not be monotonic, but the trend should be upwards!\n", - "\n", - "Along with training, we are also periodically evaluating the performance of the current model during the training. This was reported in logs as follows:\n", - "\n", - "```\n", - "Eval num_timesteps=100000, episode_reward=63.41 +/- 130.02\n", - "Episode length: 259.80 +/- 47.47\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Now, let us look at the visual performance of the lander.\n", - "\n", - "**Note:** The performance varies across different seeds and runs. This code is not optimized to be stable across all runs and seeds. We hope you will be able to find an optimal configuration!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/gym/wrappers/monitoring/video_recorder.py:101: DeprecationWarning: \u001b[33mWARN: is marked as deprecated and will be removed in the future.\u001b[0m\n", - " logger.deprecation(\n" - ] + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": {}, + "id": "68D-3iePDBuW", + "outputId": "3a259ce6-a11c-4027-86b8-be30f9b0d622", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 412 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/gym/wrappers/monitoring/video_recorder.py:101: DeprecationWarning: \u001b[33mWARN: is marked as deprecated and will be removed in the future.\u001b[0m\n", + " logger.deprecation(\n", + "/usr/lib/python3.10/subprocess.py:1796: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = _posixsubprocess.fork_exec(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Total reward: -449.2162305654916\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "env = gym.make(env_name, render_mode=\"rgb_array\")\n", + "vid = VideoRecorder(env, path=f\"video/{env_name}_pretraining.mp4\")\n", + "observation = env.reset()[0]\n", + "\n", + "total_reward = 0\n", + "done = False\n", + "while not done:\n", + " frame = env.render()\n", + " vid.capture_frame()\n", + " action, states = model.predict(observation, deterministic=True)\n", + " observation, reward, done, info, _ = env.step(action)\n", + " total_reward += reward\n", + "vid.close()\n", + "env.close()\n", + "print(f\"\\nTotal reward: {total_reward}\")\n", + "\n", + "# show video\n", + "html = render_mp4(f\"video/{env_name}_pretraining.mp4\")\n", + "HTML(html)" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Total reward: 252.88935234615718\n" - ] + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "fhtq8GDLDBuW" + }, + "source": [ + "From the video above, we see that the lander has crashed!\n", + "It is now the time for training!\n" + ] }, { - "data": { - "text/html": [ - "" + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": {}, + "id": "Xhl3ojMwDBuW", + "outputId": "c22a910b-0983-438b-dfb6-3cc20d07992e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "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" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Eval num_timesteps=10000, episode_reward=-420.98 +/- 27.22\n", + "Episode length: 151.80 +/- 30.46\n", + "New best mean reward!\n", + "Eval num_timesteps=20000, episode_reward=-561.62 +/- 27.61\n", + "Episode length: 878.80 +/- 72.71\n", + "Eval num_timesteps=30000, episode_reward=-249.88 +/- 48.31\n", + "Episode length: 240.00 +/- 51.61\n", + "New best mean reward!\n", + "Eval num_timesteps=40000, episode_reward=-161.24 +/- 24.32\n", + "Episode length: 338.20 +/- 107.08\n", + "New best mean reward!\n", + "Eval num_timesteps=50000, episode_reward=160.32 +/- 108.81\n", + "Episode length: 241.20 +/- 55.82\n", + "New best mean reward!\n", + "Eval num_timesteps=60000, episode_reward=190.88 +/- 14.49\n", + "Episode length: 646.80 +/- 65.03\n", + "New best mean reward!\n", + "Eval num_timesteps=70000, episode_reward=67.05 +/- 92.04\n", + "Episode length: 139.80 +/- 35.46\n", + "Eval num_timesteps=80000, episode_reward=267.52 +/- 20.00\n", + "Episode length: 321.60 +/- 31.12\n", + "New best mean reward!\n", + "Eval num_timesteps=90000, episode_reward=67.08 +/- 126.76\n", + "Episode length: 536.00 +/- 257.21\n", + "Eval num_timesteps=100000, episode_reward=259.59 +/- 13.39\n", + "Episode length: 339.80 +/- 19.18\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 9 + } ], - "text/plain": [ - "" + "source": [ + "model.learn(total_timesteps=100000, log_interval=10, callback=callback)\n", + "# The performance of the training will be printed every 10 episodes. Change it to 1, if you wish to\n", + "# view the performance at every training episode." ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "env = gym.make(env_name, render_mode=\"rgb_array\")\n", - "vid = VideoRecorder(env, path=f\"video/{env_name}_learned.mp4\")\n", - "observation = env.reset()[0]\n", - "\n", - "total_reward = 0\n", - "done = False\n", - "while not done:\n", - " frame = env.render()\n", - " vid.capture_frame()\n", - " action, states = model.predict(observation, deterministic=True)\n", - " observation, reward, done, info, _ = env.step(action)\n", - " total_reward += reward\n", - "vid.close()\n", - "env.close()\n", - "print(f\"\\nTotal reward: {total_reward}\")\n", - "\n", - "# show video\n", - "html = render_mp4(f\"video/{env_name}_learned.mp4\")\n", - "HTML(html)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "The lander has landed safely!!\n", - "\n", - "Let us analyze its performance (speed and stability). For this purpose, we plot the number of time steps on the x-axis and the episodic reward given by the trained model on the y-axis." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + }, { - "name": "stderr", - "output_type": "stream", - "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", + "metadata": { + "execution": {}, + "id": "IYynM83tDBuX" + }, + "source": [ + "The training takes time. We encourage you to analyze the output logs (set verbose to 1 to print the output logs). The main component of the logs that you should track is \"ep_rew_mean\" (mean of episode rewards). As the training proceeds, the value of \"ep_rew_mean\" should increase. The improvement need not be monotonic, but the trend should be upwards!\n", + "\n", + "Along with training, we are also periodically evaluating the performance of the current model during the training. This was reported in logs as follows:\n", + "\n", + "```\n", + "Eval num_timesteps=100000, episode_reward=63.41 +/- 130.02\n", + "Episode length: 259.80 +/- 47.47\n", + "```" + ] }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "UFNQVKokDBuX" + }, + "source": [ + "Now, let us look at the visual performance of the lander.\n", + "\n", + "**Note:** The performance varies across different seeds and runs. This code is not optimized to be stable across all runs and seeds. We hope you will be able to find an optimal configuration!" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "x, y = ts2xy(load_results(log_dir), 'timesteps') # Organising the logged results in to a clean format for plotting.\n", - "plt.plot(x, y)\n", - "plt.ylim([-300, 300])\n", - "plt.xlabel('Timesteps')\n", - "plt.ylabel('Episode Rewards')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "From the above plot, we observe that, although the maximum reward is achieved quickly. Achieving an episodic reward of > 200 is good. We see that the agent has achieved it in less than 50000 timesteps (speed is good!). However, there are a lot of fluctuations in the performance (stability is not good!).\n", - "\n", - "Your objective now is to modify the model parameters (nn_layers, learning_rate in the code cell #2 above), run all the cells following it and investigate the stability and speed of the chosen configuration. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "---\n", - "# Additional Project Ideas" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "## 1 Play with exploration-exploitation trade-off\n", - "\n", - "Exploration (selecting random actions) and exploitation (selecting greedy action) is a crucial component of the DQN algorithm. Explore random actions for a long time will slow down the training process. At the same time, if all actions are not explored enough, it might lead to a sub-optimal performance. In the DQN code above, we have used the following parameters:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + }, { - "name": "stderr", - "output_type": "stream", - "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" - ] - } - ], - "source": [ - "exploration_initial_eps = 1 # initial value of random action probability. Range is between 0 and 1.\n", - "exploration_fraction = 0.5 # fraction of entire training period over which the exploration rate is reduced. Range is between 0 and 1.\n", - "exploration_final_eps = 0.05 # (set by defualt) final value of random action probability. Range is between 0 and 1." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Your objective is to play around with these parameters and analyze their performance (speed and stability). You can modify these parameters and set them as arguments in DQN(...,exploration_initial_eps = 1, exploration_fraction = 0.5, exploration_final_eps = 0.05,...)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "## 2 Reward Shaping\n", - "\n", - "Your objective here is to construct a modified reward function that improves the performance of the Lunar Lander. To this end, you would have to create your own custom environment. An example of a custom environment is given below:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "# Taken from https://stable-baselines3.readthedocs.io/en/master/guide/custom_env.html\n", - "class CustomEnv(gym.Env):\n", - " \"\"\"Custom Environment that follows gym interface\"\"\"\n", - " metadata = {'render.modes': ['human']}\n", - "\n", - " def __init__(self, arg1, arg2):\n", - " super(CustomEnv, self).__init__()\n", - " # Define action and observation space\n", - " # They must be gym.spaces objects\n", - " # Example when using discrete actions:\n", - " self.action_space = spaces.Discrete(N_DISCRETE_ACTIONS)\n", - " # Example for using image as input (channel-first; channel-last also works):\n", - " self.observation_space = spaces.Box(low=0, high=255,\n", - " shape=(N_CHANNELS, HEIGHT, WIDTH), dtype=np.uint8)\n", - "\n", - " def step(self, action):\n", - " ...\n", - " return observation, reward, done, info\n", - " def reset(self):\n", - " ...\n", - " return observation # reward, done, info can't be included\n", - " def render(self, mode='human'):\n", - " ...\n", - " def close (self):\n", - " ..." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "As you are only changing the reward structure, you can inherit the [original Lunar Lander environment](https://github.com/openai/gym/blob/master/gym/envs/box2d/lunar_lander.py) and modify just the \"step\" function. Focus on modifying the following part of the code in the \"step\" function." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "class Custom_LunarLander(LunarLander):\n", - "\n", - " def step(self, action):\n", - " assert self.lander is not None\n", - "\n", - " # Update wind\n", - " assert self.lander is not None, \"You forgot to call reset()\"\n", - " if self.enable_wind and not (\n", - " self.legs[0].ground_contact or self.legs[1].ground_contact\n", - " ):\n", - " # the function used for wind is tanh(sin(2 k x) + sin(pi k x)),\n", - " # which is proven to never be periodic, k = 0.01\n", - " wind_mag = (\n", - " math.tanh(\n", - " math.sin(0.02 * self.wind_idx)\n", - " + (math.sin(math.pi * 0.01 * self.wind_idx))\n", - " )\n", - " * self.wind_power\n", - " )\n", - " self.wind_idx += 1\n", - " self.lander.ApplyForceToCenter(\n", - " (wind_mag, 0.0),\n", - " True,\n", - " )\n", - "\n", - " # the function used for torque is tanh(sin(2 k x) + sin(pi k x)),\n", - " # which is proven to never be periodic, k = 0.01\n", - " torque_mag = math.tanh(\n", - " math.sin(0.02 * self.torque_idx)\n", - " + (math.sin(math.pi * 0.01 * self.torque_idx))\n", - " ) * (self.turbulence_power)\n", - " self.torque_idx += 1\n", - " self.lander.ApplyTorque(\n", - " (torque_mag),\n", - " True,\n", - " )\n", - "\n", - " if self.continuous:\n", - " action = np.clip(action, -1, +1).astype(np.float32)\n", - " else:\n", - " assert self.action_space.contains(\n", - " action\n", - " ), f\"{action!r} ({type(action)}) invalid \"\n", - "\n", - " # Engines\n", - " tip = (math.sin(self.lander.angle), math.cos(self.lander.angle))\n", - " side = (-tip[1], tip[0])\n", - " dispersion = [self.np_random.uniform(-1.0, +1.0) / SCALE for _ in range(2)]\n", - "\n", - " m_power = 0.0\n", - " if (self.continuous and action[0] > 0.0) or (\n", - " not self.continuous and action == 2\n", - " ):\n", - " # Main engine\n", - " if self.continuous:\n", - " m_power = (np.clip(action[0], 0.0, 1.0) + 1.0) * 0.5 # 0.5..1.0\n", - " assert m_power >= 0.5 and m_power <= 1.0\n", - " else:\n", - " m_power = 1.0\n", - " # 4 is move a bit downwards, +-2 for randomness\n", - " ox = tip[0] * (4 / SCALE + 2 * dispersion[0]) + side[0] * dispersion[1]\n", - " oy = -tip[1] * (4 / SCALE + 2 * dispersion[0]) - side[1] * dispersion[1]\n", - " impulse_pos = (self.lander.position[0] + ox, self.lander.position[1] + oy)\n", - " p = self._create_particle(\n", - " 3.5, # 3.5 is here to make particle speed adequate\n", - " impulse_pos[0],\n", - " impulse_pos[1],\n", - " m_power,\n", - " ) # particles are just a decoration\n", - " p.ApplyLinearImpulse(\n", - " (ox * MAIN_ENGINE_POWER * m_power, oy * MAIN_ENGINE_POWER * m_power),\n", - " impulse_pos,\n", - " True,\n", - " )\n", - " self.lander.ApplyLinearImpulse(\n", - " (-ox * MAIN_ENGINE_POWER * m_power, -oy * MAIN_ENGINE_POWER * m_power),\n", - " impulse_pos,\n", - " True,\n", - " )\n", - "\n", - " s_power = 0.0\n", - " if (self.continuous and np.abs(action[1]) > 0.5) or (\n", - " not self.continuous and action in [1, 3]\n", - " ):\n", - " # Orientation engines\n", - " if self.continuous:\n", - " direction = np.sign(action[1])\n", - " s_power = np.clip(np.abs(action[1]), 0.5, 1.0)\n", - " assert s_power >= 0.5 and s_power <= 1.0\n", - " else:\n", - " direction = action - 2\n", - " s_power = 1.0\n", - " ox = tip[0] * dispersion[0] + side[0] * (\n", - " 3 * dispersion[1] + direction * SIDE_ENGINE_AWAY / SCALE\n", - " )\n", - " oy = -tip[1] * dispersion[0] - side[1] * (\n", - " 3 * dispersion[1] + direction * SIDE_ENGINE_AWAY / SCALE\n", - " )\n", - " impulse_pos = (\n", - " self.lander.position[0] + ox - tip[0] * 17 / SCALE,\n", - " self.lander.position[1] + oy + tip[1] * SIDE_ENGINE_HEIGHT / SCALE,\n", - " )\n", - " p = self._create_particle(0.7, impulse_pos[0], impulse_pos[1], s_power)\n", - " p.ApplyLinearImpulse(\n", - " (ox * SIDE_ENGINE_POWER * s_power, oy * SIDE_ENGINE_POWER * s_power),\n", - " impulse_pos,\n", - " True,\n", - " )\n", - " self.lander.ApplyLinearImpulse(\n", - " (-ox * SIDE_ENGINE_POWER * s_power, -oy * SIDE_ENGINE_POWER * s_power),\n", - " impulse_pos,\n", - " True,\n", - " )\n", - "\n", - " self.world.Step(1.0 / FPS, 6 * 30, 2 * 30)\n", - "\n", - " pos = self.lander.position\n", - " vel = self.lander.linearVelocity\n", - " state = [\n", - " (pos.x - VIEWPORT_W / SCALE / 2) / (VIEWPORT_W / SCALE / 2),\n", - " (pos.y - (self.helipad_y + LEG_DOWN / SCALE)) / (VIEWPORT_H / SCALE / 2),\n", - " vel.x * (VIEWPORT_W / SCALE / 2) / FPS,\n", - " vel.y * (VIEWPORT_H / SCALE / 2) / FPS,\n", - " self.lander.angle,\n", - " 20.0 * self.lander.angularVelocity / FPS,\n", - " 1.0 if self.legs[0].ground_contact else 0.0,\n", - " 1.0 if self.legs[1].ground_contact else 0.0,\n", - " ]\n", - " assert len(state) == 8\n", - "\n", - " # Compare with / without shaping, referring the state description below\n", - " '''\n", - " state[0]: the horizontal coordinate\n", - " state[1]: the vertical coordinate\n", - " state[2]: the horizontal speed\n", - " state[3]: the vertical speed\n", - " state[4]: the angle\n", - " state[5]: the angular speed\n", - " state[6]: first leg contact\n", - " state[7]: second leg contact\n", - " '''\n", - " reward = 0\n", - " shaping = (\n", - " -100 * np.sqrt(state[0] * state[0] + state[1] * state[1])\n", - " - 100 * np.sqrt(state[2] * state[2] + state[3] * state[3])\n", - " - 100 * abs(state[4])\n", - " + 10 * state[6]\n", - " + 10 * state[7]\n", - " ) # And ten points for legs contact, the idea is if you\n", - " # lose contact again after landing, you get negative reward\n", - " if self.prev_shaping is not None:\n", - " reward = shaping - self.prev_shaping\n", - " self.prev_shaping = shaping\n", - "\n", - " reward -= (\n", - " m_power * 0.30\n", - " ) # less fuel spent is better, about -30 for heuristic landing\n", - " reward -= s_power * 0.03\n", - "\n", - " terminated = False\n", - " if self.game_over or abs(state[0]) >= 1.0:\n", - " terminated = True\n", - " reward = -100\n", - " if not self.lander.awake:\n", - " terminated = True\n", - " reward = +100\n", - "\n", - " if self.render_mode == \"human\":\n", - " self.render()\n", - " return np.array(state, dtype=np.float32), reward, terminated, False, {}" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Once you have cutomized your own environment, you can execute that environment by just calling:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "## Enter the name of the custome environment you created and uncomment the line below.\n", - "# env = Custom_LunarLander()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "**Note:** Refer to [this page](https://stable-baselines3.readthedocs.io/en/master/guide/custom_env.html), if you would like to create more complex environments." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "## 3 Identify the state information crucial to its performance.\n", - "\n", - "Your objective here is to alter the input state information and analyze the performance. The input state of the Lunar Lander consists of following components:\n", - "\n", - " 1. Horizontal Position\n", - " 2. Vertical Position\n", - " 3. Horizontal Velocity\n", - " 4. Vertical Velocity\n", - " 5. Angle\n", - " 6. Angular Velocity\n", - " 7. Left Leg Contact\n", - " 8. Right Leg Contact\n", - "\n", - "You can train the algorithm by masking one of the eight components at a time and understand how that affects the performance of the algorithm. Similar to the reward shaping task, you would have to create a custom environment and modify the state space. Again, you can inherit all the necessary functions and modify the following portion of the \"Step\" function:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "def step(self, actions):\n", - " ...\n", - " ...\n", - " ...\n", - " state = [ # Remove one component at a time to investigate the effect on performance!\n", - " (pos.x - VIEWPORT_W / SCALE / 2) / (VIEWPORT_W / SCALE / 2),\n", - " (pos.y - (self.helipad_y + LEG_DOWN / SCALE)) / (VIEWPORT_H / SCALE / 2),\n", - " vel.x * (VIEWPORT_W / SCALE / 2) / FPS,\n", - " vel.y * (VIEWPORT_H / SCALE / 2) / FPS,\n", - " self.lander.angle,\n", - " 20.0 * self.lander.angularVelocity / FPS,\n", - " 1.0 if self.legs[0].ground_contact else 0.0,\n", - " 1.0 if self.legs[1].ground_contact else 0.0,\n", - " ]" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "## 4 Extension to Atari Games\n", - "\n", - "In the Lunar Lander task, the input to the algorithm is a vector of state information. Deep RL algorithms can also be applied when the input to the training is image frames, which is the case in the Atari games. For example, consider an Atari game - Pong. In this environment, the observation is an RGB image of the screen, which is an array of shape (210, 160, 3). To train the Pong game, you can start with the following sample code:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "## Taken from: https://colab.research.google.com/github/Stable-Baselines-Team/rl-colab-notebooks/blob/sb3/atari_games.ipynb#scrollTo=f3K4rMXwimBO\n", - "env = make_atari_env('PongNoFrameskip-v4', n_envs=4, seed=0)\n", - "\n", - "## Atari Games take a lot of memory. Following commands crash on Coalb. Run the following code on Colab Pro or your local Jupyter notebook!\n", - "# env = VecFrameStack(env, n_stack=4)\n", - "# model = DQN('CnnPolicy', env, verbose=1) # Note the difference here! We use 'CnnPolicy\" here instead of 'MlpPolicy' as the input is frames.\n", - "# model.learn(total_timesteps=1) #change the number of timesteps as desired and run this command!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "## 5 Obstacle Avoidance and Transfer Learning\n", - "\n", - "Your obstacle here is to add an obstacle in the path of the lunar lander (by creating a custom environment as described in point 2 above) and train the model such that the lander lands safely, avoiding collisions.\n", - "\n", - "You would first want to devise a mechansim for adding obstacles. For example, you could have an imaginary obstacle at some horizantal and vertical position cooridnates and modify the reward function such that a penalty is levied if the lander comes close to it.\n", - "\n", - "An interesting approach to solve this problem is to apply the techniques of transfer learning. For example, you could initialise the neural network model with the weights of the trained model on the original problem to improve the sample effeciency. This can be done using the following code:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "## Specify the load path and uncomment below:\n", - "\n", - "# model = load(load_path,\n", - "# env=gym.make('LunarLander-v2'),\n", - "# custom_objects=None, **kwargs)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Following are some of the resources on transfer learning that you would want to start with.\n", - "\n", - "**Research Papers**\n", - "\n", - "Surveys:\n", - "1. Taylor, M. E., et al. (2009). Transfer learning for reinforcement learning domains. url: [www.jmlr.org/papers/volume10/taylor09a/taylor09a](https://www.jmlr.org/papers/volume10/taylor09a/taylor09a.pdf)\n", - " - Long, Old, Highly cited\n", - "\n", - "2. Lazaric, A. (2012). Transfer in reinforcement learning: a framework and a survey. url: [hal.inria.fr/docs/00/77/26/26/PDF/transfer](https://hal.inria.fr/docs/00/77/26/26/PDF/transfer.pdf)\n", - " - Medium, Old, Good for a quick read\n", - "\n", - "3. Zhu, Z., Lin, K., & Zhou, J. (2020). Transfer learning in deep reinforcement learning. [arxiv:2009.07888](https://arxiv.org/pdf/2009.07888.pdf)\n", - " - Medium, Recent, Good for a quick read\n", - "\n", - "4. Barreto, A., et al. (2016). Successor features for transfer in reinforcement learning. [arxiv:1606.05312](https://arxiv.org/pdf/1606.05312)\n", - " - Specific example" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "## 5(b) Transfer Learning in minigrid environment\n", - "\n", - "These are some simple gridworld gym environments designed to be particularly simple, lightweight and fast. Refer to [this repo](https://github.com/maximecb/gym-minigrid) for a description of the environments. An example to load a minigrid environment is given below." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [], - "source": [ - "env = gym.make('MiniGrid-Empty-5x5-v0', render_mode='rgb_array')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "You can train a standard DQN agent in this env by wrapping the env with full image observation wrappers:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "execution": {} - }, - "outputs": [ + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": {}, + "id": "hc0xXn5aDBuX", + "outputId": "2bf3c03e-00b6-4d5f-a5a0-0d9077d30537", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 412 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/gym/wrappers/monitoring/video_recorder.py:101: DeprecationWarning: \u001b[33mWARN: is marked as deprecated and will be removed in the future.\u001b[0m\n", + " logger.deprecation(\n", + "/usr/lib/python3.10/subprocess.py:1796: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = _posixsubprocess.fork_exec(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Total reward: 249.47508187060953\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ], + "source": [ + "env = gym.make(env_name, render_mode=\"rgb_array\")\n", + "vid = VideoRecorder(env, path=f\"video/{env_name}_learned.mp4\")\n", + "observation = env.reset()[0]\n", + "\n", + "total_reward = 0\n", + "done = False\n", + "while not done:\n", + " frame = env.render()\n", + " vid.capture_frame()\n", + " action, states = model.predict(observation, deterministic=True)\n", + " observation, reward, done, info, _ = env.step(action)\n", + " total_reward += reward\n", + "vid.close()\n", + "env.close()\n", + "print(f\"\\nTotal reward: {total_reward}\")\n", + "\n", + "# show video\n", + "html = render_mp4(f\"video/{env_name}_learned.mp4\")\n", + "HTML(html)" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/gymnasium/core.py:311: UserWarning: \u001b[33mWARN: env.width to get variables from other wrappers is deprecated and will be removed in v1.0, to get this variable you can do `env.unwrapped.width` for environment variables or `env.get_wrapper_attr('width')` that will search the reminding wrappers.\u001b[0m\n", - " logger.warn(\n", - "/usr/local/lib/python3.10/dist-packages/gymnasium/core.py:311: UserWarning: \u001b[33mWARN: env.height to get variables from other wrappers is deprecated and will be removed in v1.0, to get this variable you can do `env.unwrapped.height` for environment variables or `env.get_wrapper_attr('height')` that will search the reminding wrappers.\u001b[0m\n", - " logger.warn(\n" - ] + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "cVCcx8GUDBuX" + }, + "source": [ + "The lander has landed safely!!\n", + "\n", + "Let us analyze its performance (speed and stability). For this purpose, we plot the number of time steps on the x-axis and the episodic reward given by the trained model on the y-axis." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": {}, + "id": "_8ibUiTmDBuX", + "outputId": "25fbda7f-4dc6-47e6-c1e9-0d765db9e6b6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 510 + } + }, + "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" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "x, y = ts2xy(load_results(log_dir), 'timesteps') # Organising the logged results in to a clean format for plotting.\n", + "plt.plot(x, y)\n", + "plt.ylim([-300, 300])\n", + "plt.xlabel('Timesteps')\n", + "plt.ylabel('Episode Rewards')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "2Zo8kpDUDBuX" + }, + "source": [ + "From the above plot, we observe that, although the maximum reward is achieved quickly. Achieving an episodic reward of > 200 is good. We see that the agent has achieved it in less than 50000 timesteps (speed is good!). However, there are a lot of fluctuations in the performance (stability is not good!).\n", + "\n", + "Your objective now is to modify the model parameters (nn_layers, learning_rate in the code cell #2 above), run all the cells following it and investigate the stability and speed of the chosen configuration. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "D7JAEDEzDBuX" + }, + "source": [ + "---\n", + "# Additional Project Ideas" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "1m6YBf5nDBuX" + }, + "source": [ + "## 1 Play with exploration-exploitation trade-off\n", + "\n", + "Exploration (selecting random actions) and exploitation (selecting greedy action) is a crucial component of the DQN algorithm. Explore random actions for a long time will slow down the training process. At the same time, if all actions are not explored enough, it might lead to a sub-optimal performance. In the DQN code above, we have used the following parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": {}, + "id": "tnbb16KUDBuY", + "outputId": "2d275702-253e-4f5d-8139-2b7796c8d66f", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "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" + ] + } + ], + "source": [ + "exploration_initial_eps = 1 # initial value of random action probability. Range is between 0 and 1.\n", + "exploration_fraction = 0.5 # fraction of entire training period over which the exploration rate is reduced. Range is between 0 and 1.\n", + "exploration_final_eps = 0.05 # (set by defualt) final value of random action probability. Range is between 0 and 1." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "794AyGDPDBuY" + }, + "source": [ + "Your objective is to play around with these parameters and analyze their performance (speed and stability). You can modify these parameters and set them as arguments in DQN(...,exploration_initial_eps = 1, exploration_fraction = 0.5, exploration_final_eps = 0.05,...)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "Ljf9XG5BDBuY" + }, + "source": [ + "## 2 Reward Shaping\n", + "\n", + "Your objective here is to construct a modified reward function that improves the performance of the Lunar Lander. To this end, you would have to create your own custom environment. An example of a custom environment is given below:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": {}, + "id": "zAAhdiflDBuY" + }, + "outputs": [], + "source": [ + "# Taken from https://stable-baselines3.readthedocs.io/en/master/guide/custom_env.html\n", + "class CustomEnv(gym.Env):\n", + " \"\"\"Custom Environment that follows gym interface\"\"\"\n", + " metadata = {'render.modes': ['human']}\n", + "\n", + " def __init__(self, arg1, arg2):\n", + " super(CustomEnv, self).__init__()\n", + " # Define action and observation space\n", + " # They must be gym.spaces objects\n", + " # Example when using discrete actions:\n", + " self.action_space = spaces.Discrete(N_DISCRETE_ACTIONS)\n", + " # Example for using image as input (channel-first; channel-last also works):\n", + " self.observation_space = spaces.Box(low=0, high=255,\n", + " shape=(N_CHANNELS, HEIGHT, WIDTH), dtype=np.uint8)\n", + "\n", + " def step(self, action):\n", + " ...\n", + " return observation, reward, done, info\n", + " def reset(self):\n", + " ...\n", + " return observation # reward, done, info can't be included\n", + " def render(self, mode='human'):\n", + " ...\n", + " def close (self):\n", + " ..." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "n7u1oEO2DBuY" + }, + "source": [ + "As you are only changing the reward structure, you can inherit the [original Lunar Lander environment](https://github.com/openai/gym/blob/master/gym/envs/box2d/lunar_lander.py) and modify just the \"step\" function. Focus on modifying the following part of the code in the \"step\" function." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": {}, + "id": "463GUtbuDBuY" + }, + "outputs": [], + "source": [ + "class Custom_LunarLander(LunarLander):\n", + "\n", + " def step(self, action):\n", + " assert self.lander is not None\n", + "\n", + " # Update wind\n", + " assert self.lander is not None, \"You forgot to call reset()\"\n", + " if self.enable_wind and not (\n", + " self.legs[0].ground_contact or self.legs[1].ground_contact\n", + " ):\n", + " # the function used for wind is tanh(sin(2 k x) + sin(pi k x)),\n", + " # which is proven to never be periodic, k = 0.01\n", + " wind_mag = (\n", + " math.tanh(\n", + " math.sin(0.02 * self.wind_idx)\n", + " + (math.sin(math.pi * 0.01 * self.wind_idx))\n", + " )\n", + " * self.wind_power\n", + " )\n", + " self.wind_idx += 1\n", + " self.lander.ApplyForceToCenter(\n", + " (wind_mag, 0.0),\n", + " True,\n", + " )\n", + "\n", + " # the function used for torque is tanh(sin(2 k x) + sin(pi k x)),\n", + " # which is proven to never be periodic, k = 0.01\n", + " torque_mag = math.tanh(\n", + " math.sin(0.02 * self.torque_idx)\n", + " + (math.sin(math.pi * 0.01 * self.torque_idx))\n", + " ) * (self.turbulence_power)\n", + " self.torque_idx += 1\n", + " self.lander.ApplyTorque(\n", + " (torque_mag),\n", + " True,\n", + " )\n", + "\n", + " if self.continuous:\n", + " action = np.clip(action, -1, +1).astype(np.float32)\n", + " else:\n", + " assert self.action_space.contains(\n", + " action\n", + " ), f\"{action!r} ({type(action)}) invalid \"\n", + "\n", + " # Engines\n", + " tip = (math.sin(self.lander.angle), math.cos(self.lander.angle))\n", + " side = (-tip[1], tip[0])\n", + " dispersion = [self.np_random.uniform(-1.0, +1.0) / SCALE for _ in range(2)]\n", + "\n", + " m_power = 0.0\n", + " if (self.continuous and action[0] > 0.0) or (\n", + " not self.continuous and action == 2\n", + " ):\n", + " # Main engine\n", + " if self.continuous:\n", + " m_power = (np.clip(action[0], 0.0, 1.0) + 1.0) * 0.5 # 0.5..1.0\n", + " assert m_power >= 0.5 and m_power <= 1.0\n", + " else:\n", + " m_power = 1.0\n", + " # 4 is move a bit downwards, +-2 for randomness\n", + " ox = tip[0] * (4 / SCALE + 2 * dispersion[0]) + side[0] * dispersion[1]\n", + " oy = -tip[1] * (4 / SCALE + 2 * dispersion[0]) - side[1] * dispersion[1]\n", + " impulse_pos = (self.lander.position[0] + ox, self.lander.position[1] + oy)\n", + " p = self._create_particle(\n", + " 3.5, # 3.5 is here to make particle speed adequate\n", + " impulse_pos[0],\n", + " impulse_pos[1],\n", + " m_power,\n", + " ) # particles are just a decoration\n", + " p.ApplyLinearImpulse(\n", + " (ox * MAIN_ENGINE_POWER * m_power, oy * MAIN_ENGINE_POWER * m_power),\n", + " impulse_pos,\n", + " True,\n", + " )\n", + " self.lander.ApplyLinearImpulse(\n", + " (-ox * MAIN_ENGINE_POWER * m_power, -oy * MAIN_ENGINE_POWER * m_power),\n", + " impulse_pos,\n", + " True,\n", + " )\n", + "\n", + " s_power = 0.0\n", + " if (self.continuous and np.abs(action[1]) > 0.5) or (\n", + " not self.continuous and action in [1, 3]\n", + " ):\n", + " # Orientation engines\n", + " if self.continuous:\n", + " direction = np.sign(action[1])\n", + " s_power = np.clip(np.abs(action[1]), 0.5, 1.0)\n", + " assert s_power >= 0.5 and s_power <= 1.0\n", + " else:\n", + " direction = action - 2\n", + " s_power = 1.0\n", + " ox = tip[0] * dispersion[0] + side[0] * (\n", + " 3 * dispersion[1] + direction * SIDE_ENGINE_AWAY / SCALE\n", + " )\n", + " oy = -tip[1] * dispersion[0] - side[1] * (\n", + " 3 * dispersion[1] + direction * SIDE_ENGINE_AWAY / SCALE\n", + " )\n", + " impulse_pos = (\n", + " self.lander.position[0] + ox - tip[0] * 17 / SCALE,\n", + " self.lander.position[1] + oy + tip[1] * SIDE_ENGINE_HEIGHT / SCALE,\n", + " )\n", + " p = self._create_particle(0.7, impulse_pos[0], impulse_pos[1], s_power)\n", + " p.ApplyLinearImpulse(\n", + " (ox * SIDE_ENGINE_POWER * s_power, oy * SIDE_ENGINE_POWER * s_power),\n", + " impulse_pos,\n", + " True,\n", + " )\n", + " self.lander.ApplyLinearImpulse(\n", + " (-ox * SIDE_ENGINE_POWER * s_power, -oy * SIDE_ENGINE_POWER * s_power),\n", + " impulse_pos,\n", + " True,\n", + " )\n", + "\n", + " self.world.Step(1.0 / FPS, 6 * 30, 2 * 30)\n", + "\n", + " pos = self.lander.position\n", + " vel = self.lander.linearVelocity\n", + " state = [\n", + " (pos.x - VIEWPORT_W / SCALE / 2) / (VIEWPORT_W / SCALE / 2),\n", + " (pos.y - (self.helipad_y + LEG_DOWN / SCALE)) / (VIEWPORT_H / SCALE / 2),\n", + " vel.x * (VIEWPORT_W / SCALE / 2) / FPS,\n", + " vel.y * (VIEWPORT_H / SCALE / 2) / FPS,\n", + " self.lander.angle,\n", + " 20.0 * self.lander.angularVelocity / FPS,\n", + " 1.0 if self.legs[0].ground_contact else 0.0,\n", + " 1.0 if self.legs[1].ground_contact else 0.0,\n", + " ]\n", + " assert len(state) == 8\n", + "\n", + " # Compare with / without shaping, referring the state description below\n", + " '''\n", + " state[0]: the horizontal coordinate\n", + " state[1]: the vertical coordinate\n", + " state[2]: the horizontal speed\n", + " state[3]: the vertical speed\n", + " state[4]: the angle\n", + " state[5]: the angular speed\n", + " state[6]: first leg contact\n", + " state[7]: second leg contact\n", + " '''\n", + " reward = 0\n", + " shaping = (\n", + " -100 * np.sqrt(state[0] * state[0] + state[1] * state[1])\n", + " - 100 * np.sqrt(state[2] * state[2] + state[3] * state[3])\n", + " - 100 * abs(state[4])\n", + " + 10 * state[6]\n", + " + 10 * state[7]\n", + " ) # And ten points for legs contact, the idea is if you\n", + " # lose contact again after landing, you get negative reward\n", + " if self.prev_shaping is not None:\n", + " reward = shaping - self.prev_shaping\n", + " self.prev_shaping = shaping\n", + "\n", + " reward -= (\n", + " m_power * 0.30\n", + " ) # less fuel spent is better, about -30 for heuristic landing\n", + " reward -= s_power * 0.03\n", + "\n", + " terminated = False\n", + " if self.game_over or abs(state[0]) >= 1.0:\n", + " terminated = True\n", + " reward = -100\n", + " if not self.lander.awake:\n", + " terminated = True\n", + " reward = +100\n", + "\n", + " if self.render_mode == \"human\":\n", + " self.render()\n", + " return np.array(state, dtype=np.float32), reward, terminated, False, {}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "V-qZ4WYxDBuZ" + }, + "source": [ + "Once you have cutomized your own environment, you can execute that environment by just calling:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "execution": {}, + "id": "yq4902DQDBuZ" + }, + "outputs": [], + "source": [ + "## Enter the name of the custome environment you created and uncomment the line below.\n", + "# env = Custom_LunarLander()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "EAP-DUd6DBuZ" + }, + "source": [ + "**Note:** Refer to [this page](https://stable-baselines3.readthedocs.io/en/master/guide/custom_env.html), if you would like to create more complex environments." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "QTq0hmHCDBuZ" + }, + "source": [ + "## 3 Identify the state information crucial to its performance.\n", + "\n", + "Your objective here is to alter the input state information and analyze the performance. The input state of the Lunar Lander consists of following components:\n", + "\n", + " 1. Horizontal Position\n", + " 2. Vertical Position\n", + " 3. Horizontal Velocity\n", + " 4. Vertical Velocity\n", + " 5. Angle\n", + " 6. Angular Velocity\n", + " 7. Left Leg Contact\n", + " 8. Right Leg Contact\n", + "\n", + "You can train the algorithm by masking one of the eight components at a time and understand how that affects the performance of the algorithm. Similar to the reward shaping task, you would have to create a custom environment and modify the state space. Again, you can inherit all the necessary functions and modify the following portion of the \"Step\" function:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": {}, + "id": "sz45kgEaDBuZ" + }, + "outputs": [], + "source": [ + "def step(self, actions):\n", + " ...\n", + " ...\n", + " ...\n", + " state = [ # Remove one component at a time to investigate the effect on performance!\n", + " (pos.x - VIEWPORT_W / SCALE / 2) / (VIEWPORT_W / SCALE / 2),\n", + " (pos.y - (self.helipad_y + LEG_DOWN / SCALE)) / (VIEWPORT_H / SCALE / 2),\n", + " vel.x * (VIEWPORT_W / SCALE / 2) / FPS,\n", + " vel.y * (VIEWPORT_H / SCALE / 2) / FPS,\n", + " self.lander.angle,\n", + " 20.0 * self.lander.angularVelocity / FPS,\n", + " 1.0 if self.legs[0].ground_contact else 0.0,\n", + " 1.0 if self.legs[1].ground_contact else 0.0,\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "DXy9s2ymDBuZ" + }, + "source": [ + "## 4 Extension to Atari Games\n", + "\n", + "In the Lunar Lander task, the input to the algorithm is a vector of state information. Deep RL algorithms can also be applied when the input to the training is image frames, which is the case in the Atari games. For example, consider an Atari game - Pong. In this environment, the observation is an RGB image of the screen, which is an array of shape (210, 160, 3). To train the Pong game, you can start with the following sample code:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "execution": {}, + "id": "4RjAt0W-DBuZ" + }, + "outputs": [], + "source": [ + "## Taken from: https://colab.research.google.com/github/Stable-Baselines-Team/rl-colab-notebooks/blob/sb3/atari_games.ipynb#scrollTo=f3K4rMXwimBO\n", + "env = make_atari_env('PongNoFrameskip-v4', n_envs=4, seed=0)\n", + "\n", + "## Atari Games take a lot of memory. Following commands crash on Coalb. Run the following code on Colab Pro or your local Jupyter notebook!\n", + "# env = VecFrameStack(env, n_stack=4)\n", + "# model = DQN('CnnPolicy', env, verbose=1) # Note the difference here! We use 'CnnPolicy\" here instead of 'MlpPolicy' as the input is frames.\n", + "# model.learn(total_timesteps=1) #change the number of timesteps as desired and run this command!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "E6_fFAYhDBue" + }, + "source": [ + "## 5 Obstacle Avoidance and Transfer Learning\n", + "\n", + "Your obstacle here is to add an obstacle in the path of the lunar lander (by creating a custom environment as described in point 2 above) and train the model such that the lander lands safely, avoiding collisions.\n", + "\n", + "You would first want to devise a mechansim for adding obstacles. For example, you could have an imaginary obstacle at some horizantal and vertical position cooridnates and modify the reward function such that a penalty is levied if the lander comes close to it.\n", + "\n", + "An interesting approach to solve this problem is to apply the techniques of transfer learning. For example, you could initialise the neural network model with the weights of the trained model on the original problem to improve the sample effeciency. This can be done using the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": {}, + "id": "h6knZ3U8DBue" + }, + "outputs": [], + "source": [ + "## Specify the load path and uncomment below:\n", + "\n", + "# model = load(load_path,\n", + "# env=gym.make('LunarLander-v2'),\n", + "# custom_objects=None, **kwargs)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "GXBIbO25DBue" + }, + "source": [ + "Following are some of the resources on transfer learning that you would want to start with.\n", + "\n", + "**Research Papers**\n", + "\n", + "Surveys:\n", + "1. Taylor, M. E., et al. (2009). Transfer learning for reinforcement learning domains. url: [www.jmlr.org/papers/volume10/taylor09a/taylor09a](https://www.jmlr.org/papers/volume10/taylor09a/taylor09a.pdf)\n", + " - Long, Old, Highly cited\n", + "\n", + "2. Lazaric, A. (2012). Transfer in reinforcement learning: a framework and a survey. url: [hal.inria.fr/docs/00/77/26/26/PDF/transfer](https://hal.inria.fr/docs/00/77/26/26/PDF/transfer.pdf)\n", + " - Medium, Old, Good for a quick read\n", + "\n", + "3. Zhu, Z., Lin, K., & Zhou, J. (2020). Transfer learning in deep reinforcement learning. [arxiv:2009.07888](https://arxiv.org/pdf/2009.07888.pdf)\n", + " - Medium, Recent, Good for a quick read\n", + "\n", + "4. Barreto, A., et al. (2016). Successor features for transfer in reinforcement learning. [arxiv:1606.05312](https://arxiv.org/pdf/1606.05312)\n", + " - Specific example" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "MlOksW3ODBue" + }, + "source": [ + "## 5(b) Transfer Learning in minigrid environment\n", + "\n", + "These are some simple gridworld gym environments designed to be particularly simple, lightweight and fast. Refer to [this repo](https://github.com/maximecb/gym-minigrid) for a description of the environments. An example to load a minigrid environment is given below." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "execution": {}, + "id": "v7rB2JQlDBue" + }, + "outputs": [], + "source": [ + "env = gym.make('MiniGrid-Empty-5x5-v0', render_mode='rgb_array')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "OPcds7ZtDBue" + }, + "source": [ + "You can train a standard DQN agent in this env by wrapping the env with full image observation wrappers:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "execution": {}, + "id": "d0NiSkyeDBue", + "outputId": "ae937a7d-d815-46ac-c29c-44c650f50c22", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/gymnasium/core.py:311: UserWarning: \u001b[33mWARN: env.width to get variables from other wrappers is deprecated and will be removed in v1.0, to get this variable you can do `env.unwrapped.width` for environment variables or `env.get_wrapper_attr('width')` that will search the reminding wrappers.\u001b[0m\n", + " logger.warn(\n", + "/usr/local/lib/python3.10/dist-packages/gymnasium/core.py:311: UserWarning: \u001b[33mWARN: env.height to get variables from other wrappers is deprecated and will be removed in v1.0, to get this variable you can do `env.unwrapped.height` for environment variables or `env.get_wrapper_attr('height')` that will search the reminding wrappers.\u001b[0m\n", + " logger.warn(\n" + ] + } + ], + "source": [ + "import minigrid\n", + "env = minigrid.wrappers.ImgObsWrapper(minigrid.wrappers.RGBImgObsWrapper(env))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "7J92iMqqDBue" + }, + "source": [ + "Note that with full image observations, the shape of the image observations may differ between envs. For e.g., MiniGrid-Empty-5x5-v0 is (40,40,3) while MiniGrid-Empty-8x8-v0 is (64,64,3). So you may need to resize the observations for transfer learning to work with the same DQN architecture.\n", + "\n", + "Now try training a DQN (or another method) in one (or multiple) minigrid env(s),and see if that knowledge transfers to another (or multiple other) minigrid env(s).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "HL0W5M4uDBue" + }, + "source": [ + "## 6 Preference-Based RL (PBRL)\n", + "\n", + "PBRL is an exciting sub-area in RL where the traditional reward structure is replaced with human preferences. This setting is very useful in applications where it is difficult to construct a reward function.\n", + "\n", + "In the earlier section, we have successfully trained the lunar lander to land safely. Here, the path that the lander follows to land safely can be arbitrary. In this project, using the techniques of PBRL, you will solve the lunar lander problem with an additional requirement that the lander should follow a specially curated path (for example, a straight line path). Following are some of the resources that will help you to get started with this project.\n", + "\n", + "**Research papers:**\n", + "1. [Deep Reinforcement Learning from Human Preferences](https://papers.nips.cc/paper/2017/file/d5e2c0adad503c91f91df240d0cd4e49-Paper.pdf)\n", + "2. [Deep Q-learning from Demonstrations](https://arxiv.org/pdf/1704.03732.pdf)\n", + "3. [Reward learning from human preferences](https://arxiv.org/pdf/1811.06521.pdf)\n", + "4. [T-REX](https://arxiv.org/pdf/1904.06387.pdf)\n", + "\n", + "**Code Bases:**\n", + "1. [rl-teacher](https://github.com/nottombrown/rl-teacher)\n", + "2. [ICML2019-TREX](https://github.com/hiwonjoon/ICML2019-TREX)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": {}, + "id": "QdW-XKCMDBue" + }, + "source": [ + "---\n", + "# References\n", + "\n", + "1. [Stable Baselines Framework](https://stable-baselines3.readthedocs.io/en/master/guide/examples.html)\n", + "2. [Lunar Lander Environment](https://gym.openai.com/envs/LunarLander-v2/)\n", + "3. [OpenAI gym environments](https://gym.openai.com/docs/)\n", + "4. [A good reference for introduction to RL](http://incompleteideas.net/book/the-book-2nd.html)\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "name": "lunar_lander", + "provenance": [], + "toc_visible": true + }, + "gpuClass": "standard", + "kernel": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" } - ], - "source": [ - "import minigrid\n", - "env = minigrid.wrappers.ImgObsWrapper(minigrid.wrappers.RGBImgObsWrapper(env))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "Note that with full image observations, the shape of the image observations may differ between envs. For e.g., MiniGrid-Empty-5x5-v0 is (40,40,3) while MiniGrid-Empty-8x8-v0 is (64,64,3). So you may need to resize the observations for transfer learning to work with the same DQN architecture.\n", - "\n", - "Now try training a DQN (or another method) in one (or multiple) minigrid env(s),and see if that knowledge transfers to another (or multiple other) minigrid env(s).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "## 6 Preference-Based RL (PBRL)\n", - "\n", - "PBRL is an exciting sub-area in RL where the traditional reward structure is replaced with human preferences. This setting is very useful in applications where it is difficult to construct a reward function.\n", - "\n", - "In the earlier section, we have successfully trained the lunar lander to land safely. Here, the path that the lander follows to land safely can be arbitrary. In this project, using the techniques of PBRL, you will solve the lunar lander problem with an additional requirement that the lander should follow a specially curated path (for example, a straight line path). Following are some of the resources that will help you to get started with this project.\n", - "\n", - "**Research papers:**\n", - "1. [Deep Reinforcement Learning from Human Preferences](https://papers.nips.cc/paper/2017/file/d5e2c0adad503c91f91df240d0cd4e49-Paper.pdf)\n", - "2. [Deep Q-learning from Demonstrations](https://arxiv.org/pdf/1704.03732.pdf)\n", - "3. [Reward learning from human preferences](https://arxiv.org/pdf/1811.06521.pdf)\n", - "4. [T-REX](https://arxiv.org/pdf/1904.06387.pdf)\n", - "\n", - "**Code Bases:**\n", - "1. [rl-teacher](https://github.com/nottombrown/rl-teacher)\n", - "2. [ICML2019-TREX](https://github.com/hiwonjoon/ICML2019-TREX)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "execution": {} - }, - "source": [ - "---\n", - "# References\n", - "\n", - "1. [Stable Baselines Framework](https://stable-baselines3.readthedocs.io/en/master/guide/examples.html)\n", - "2. [Lunar Lander Environment](https://gym.openai.com/envs/LunarLander-v2/)\n", - "3. [OpenAI gym environments](https://gym.openai.com/docs/)\n", - "4. [A good reference for introduction to RL](http://incompleteideas.net/book/the-book-2nd.html)\n" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "collapsed_sections": [], - "include_colab_link": true, - "name": "lunar_lander", - "provenance": [], - "toc_visible": true - }, - "gpuClass": "standard", - "kernel": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file