"
],
"text/plain": [
" episode_length episode_return steps_per_second episodes steps\n",
- "995 32 -10.0 329.379165 996 31872\n",
- "996 32 -11.0 326.324034 997 31904\n",
- "997 32 -9.0 373.017676 998 31936\n",
- "998 32 -11.0 309.737031 999 31968\n",
- "999 32 -9.0 405.329983 1000 32000"
+ "995 32 -13.0 1049.248175 996 31872\n",
+ "996 32 -13.0 1113.221097 997 31904\n",
+ "997 32 -14.0 1053.158887 998 31936\n",
+ "998 32 -19.0 1213.915019 999 31968\n",
+ "999 32 -11.0 1209.724540 1000 32000"
]
},
"execution_count": 11,
@@ -1283,11 +978,23 @@
"name": "python3"
},
"kernelspec": {
- "display_name": "Python 3",
+ "display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.16"
}
},
"nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 4
}
diff --git a/projects/ReinforcementLearning/lunar_lander.ipynb b/projects/ReinforcementLearning/lunar_lander.ipynb
index 80b6eda54..adf6b71b6 100644
--- a/projects/ReinforcementLearning/lunar_lander.ipynb
+++ b/projects/ReinforcementLearning/lunar_lander.ipynb
@@ -1,1300 +1,1306 @@
{
- "cells": [
- {
- "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"
- ]
- },
- {
- "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)?"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "execution": {},
- "id": "x5XKBDyYDBuS"
- },
- "source": [
- "---\n",
- "# Setup"
- ]
- },
- {
- "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"
- ]
- },
- {
- "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"
- ]
- },
- {
- "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"
- ]
- },
- {
- "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''"
- ]
- },
- {
- "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",
- ""
- ]
- },
- {
- "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"
- ]
- }
- ],
- "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": {},
- "id": "EHLx2d5xDBuV"
- },
- "source": [
- "Now, let us setup our model and the DQN algorithm."
- ]
- },
- {
- "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\"."
- ]
- },
- {
- "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)."
- ]
- },
- {
- "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)"
- ]
- },
- {
- "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)"
- ]
- },
- {
- "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"
- ]
- },
- {
- "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
- }
- ],
- "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."
- ]
+ "cells": [
+ {
+ "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"
+ ]
+ },
+ {
+ "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)?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "execution": {},
+ "id": "x5XKBDyYDBuS"
+ },
+ "source": [
+ "---\n",
+ "# Setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "cellView": "form",
+ "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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
},
+ "id": "6fooEJQSDBuT",
+ "outputId": "73371ac6-9d7e-42e4-acee-5a0636eec589"
+ },
+ "outputs": [
{
- "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",
- "```"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "Requirement already satisfied: swig in /home/yuda/code/neuromatch/course-content-dl/venv/lib/python3.9/site-packages (4.2.1)\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.2\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
+ ]
+ }
+ ],
+ "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 --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 --quiet\n",
+ "!pip install 'minigrid<=2.1.1' --quiet\n",
+ "!pip3 install box2d-py --quiet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "cellView": "form",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
},
- {
- "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!"
- ]
+ "id": "_M-76WwDDBuT",
+ "outputId": "74dde974-1a97-4be7-e7ce-6a2964b602e2"
+ },
+ "outputs": [],
+ "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": {},
+ "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",
+ ""
+ ]
+ },
+ {
+ "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": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
},
- {
- "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)"
- ]
+ "id": "MvWRAJiSDBuV",
+ "outputId": "23422e4b-fa32-4edd-d283-31b62668d30e"
+ },
+ "outputs": [],
+ "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": {},
+ "id": "EHLx2d5xDBuV"
+ },
+ "source": [
+ "Now, let us setup our model and the DQN algorithm."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "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\"."
+ ]
+ },
+ {
+ "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)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
},
+ "id": "SyD6VwDhDBuW",
+ "outputId": "1689b33b-720e-4d7f-d8e8-56cabfb398f1"
+ },
+ "outputs": [
{
- "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."
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "State shape: (8,)\n",
+ "Number of actions: 4\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": 8,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 412
},
+ "id": "68D-3iePDBuW",
+ "outputId": "3a259ce6-a11c-4027-86b8-be30f9b0d622"
+ },
+ "outputs": [
{
- "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()"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Moviepy - Building video video/LunarLander-v2_pretraining.mp4.\n",
+ "Moviepy - Writing video video/LunarLander-v2_pretraining.mp4\n",
+ "\n"
+ ]
},
{
- "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"
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " "
+ ]
},
{
- "cell_type": "markdown",
- "metadata": {
- "execution": {},
- "id": "D7JAEDEzDBuX"
- },
- "source": [
- "---\n",
- "# Additional Project Ideas"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Moviepy - Done !\n",
+ "Moviepy - video ready video/LunarLander-v2_pretraining.mp4\n",
+ "\n",
+ "Total reward: -723.5946813053503\n"
+ ]
},
{
- "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:"
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\r"
+ ]
},
{
- "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"
- ]
- }
+ "data": {
+ "text/html": [
+ ""
],
- "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!"
+ "text/plain": [
+ ""
]
+ },
+ "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",
+ "\n",
+ "observation = env.reset()[0]\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": {},
+ "id": "fhtq8GDLDBuW"
+ },
+ "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": 9,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
},
+ "id": "Xhl3ojMwDBuW",
+ "outputId": "c22a910b-0983-438b-dfb6-3cc20d07992e"
+ },
+ "outputs": [
{
- "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:"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Eval num_timesteps=10000, episode_reward=-283.46 +/- 58.80\n",
+ "Episode length: 187.00 +/- 38.92\n",
+ "New best mean reward!\n",
+ "Eval num_timesteps=20000, episode_reward=-406.35 +/- 59.73\n",
+ "Episode length: 201.40 +/- 71.19\n",
+ "Eval num_timesteps=30000, episode_reward=-323.96 +/- 57.66\n",
+ "Episode length: 774.80 +/- 166.26\n",
+ "Eval num_timesteps=40000, episode_reward=69.12 +/- 117.61\n",
+ "Episode length: 418.00 +/- 31.63\n",
+ "New best mean reward!\n",
+ "Eval num_timesteps=50000, episode_reward=-170.94 +/- 98.78\n",
+ "Episode length: 145.40 +/- 73.48\n",
+ "Eval num_timesteps=60000, episode_reward=147.63 +/- 90.91\n",
+ "Episode length: 543.60 +/- 90.69\n",
+ "New best mean reward!\n",
+ "Eval num_timesteps=70000, episode_reward=-30.95 +/- 269.95\n",
+ "Episode length: 421.40 +/- 225.90\n",
+ "Eval num_timesteps=80000, episode_reward=117.20 +/- 86.79\n",
+ "Episode length: 766.40 +/- 125.80\n",
+ "Eval num_timesteps=90000, episode_reward=-26.99 +/- 20.29\n",
+ "Episode length: 639.80 +/- 441.17\n",
+ "Eval num_timesteps=100000, episode_reward=101.46 +/- 61.07\n",
+ "Episode length: 893.80 +/- 130.44\n"
+ ]
},
{
- "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)"
+ "data": {
+ "text/plain": [
+ ""
]
+ },
+ "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": {},
+ "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",
+ "```"
+ ]
+ },
+ {
+ "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!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 412
},
+ "id": "hc0xXn5aDBuX",
+ "outputId": "2bf3c03e-00b6-4d5f-a5a0-0d9077d30537"
+ },
+ "outputs": [
{
- "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"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Moviepy - Building video video/LunarLander-v2_learned.mp4.\n",
+ "Moviepy - Writing video video/LunarLander-v2_learned.mp4\n",
+ "\n"
+ ]
},
{
- "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."
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " "
+ ]
},
{
- "cell_type": "code",
- "execution_count": 19,
- "metadata": {
- "execution": {},
- "id": "v7rB2JQlDBue"
- },
- "outputs": [],
- "source": [
- "env = gym.make('MiniGrid-Empty-5x5-v0', render_mode='rgb_array')"
- ]
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Moviepy - Done !\n",
+ "Moviepy - video ready video/LunarLander-v2_learned.mp4\n",
+ "\n",
+ "Total reward: 211.6755132885056\n"
+ ]
},
{
- "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"
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\r"
+ ]
},
{
- "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"
- ]
- }
+ "data": {
+ "text/html": [
+ ""
],
- "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"
+ "text/plain": [
+ ""
]
+ },
+ "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": {},
+ "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": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 510
},
+ "id": "_8ibUiTmDBuX",
+ "outputId": "25fbda7f-4dc6-47e6-c1e9-0d765db9e6b6"
+ },
+ "outputs": [
{
- "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)"
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
]
+ },
+ "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": {},
+ "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": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
},
+ "id": "tnbb16KUDBuY",
+ "outputId": "2d275702-253e-4f5d-8139-2b7796c8d66f"
+ },
+ "outputs": [],
+ "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": {
+ "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": {
+ "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": {
+ "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": {
+ "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": {
+ "id": "4RjAt0W-DBuZ"
+ },
+ "outputs": [
{
- "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"
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "A.L.E: Arcade Learning Environment (version 0.8.1+53f58b7)\n",
+ "[Powered by Stella]\n"
+ ]
}
- ],
- "metadata": {
- "accelerator": "GPU",
+ ],
+ "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": {
+ "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": {
+ "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": {
"colab": {
- "name": "lunar_lander",
- "provenance": [],
- "toc_visible": true
+ "base_uri": "https://localhost:8080/"
},
- "gpuClass": "standard",
- "kernel": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "kernelspec": {
- "display_name": "Python 3",
- "name": "python3"
- },
- "language_info": {
- "name": "python"
+ "id": "d0NiSkyeDBue",
+ "outputId": "ae937a7d-d815-46ac-c29c-44c650f50c22"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/yuda/code/neuromatch/course-content-dl/venv/lib/python3.9/site-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",
+ "/home/yuda/code/neuromatch/course-content-dl/venv/lib/python3.9/site-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 (ipykernel)",
+ "language": "python",
+ "name": "python3"
},
- "nbformat": 4,
- "nbformat_minor": 0
-}
\ No newline at end of file
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.16"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/requirements.txt b/requirements.txt
index b8d8390a9..356436466 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,15 +1,17 @@
requests
-numpy
+numpy==1.26.4
scipy
matplotlib
scikit-learn
-torch
+torch==1.13.0
+torchvision==0.14.0
ipywidgets
tqdm
torchvision
pathlib
xkcd
-decorator==5.0.9
+decorator==4.0.2
pyvirtualdisplay
tensorboard
-moviepy
+moviepy==1.0.3
+imageio_ffmpeg
![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
![\"Open](\"https://kaggle.com/static/images/open-in-kaggle.svg\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "renayVUI7b9x",
- "metadata": {
- "execution": {},
- "id": "renayVUI7b9x"
- },
- "source": [
- "# Knowledge Extraction from a Convolutional Neural Network\n",
- "\n",
- "**By Neuromatch Academy**\n",
- "\n",
- "__Content creators:__ Jan Funke\n",
- "\n",
- "__Production editors:__ Spiros Chavlis"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "U6wofKujWp6X",
- "metadata": {
- "execution": {},
- "id": "U6wofKujWp6X"
- },
- "source": [
- "---\n",
- "# Objective\n",
- "\n",
- "Train a convolutional neural network to classify images and a CycleGAN to translate between images of different types.\n",
- "\n",
- "This notebook contains everything to train a VGG network on labelled images and to train a CycleGAN to translate between images.\n",
- "\n",
- "We will use electron microscopy images of Drosophila synapses for this project. Those images can be classified according to the neurotransmitter type they release."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "zO4YN6W8W0Cp",
- "metadata": {
- "execution": {},
- "id": "zO4YN6W8W0Cp"
- },
- "source": [
- "---\n",
- "# Setup"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "fO1IZwvkW9Me",
- "metadata": {
- "cellView": "form",
- "execution": {},
- "id": "fO1IZwvkW9Me"
- },
- "outputs": [],
- "source": [
- "# @title Install dependencies\n",
- "!pip install scikit-image --quiet\n",
- "!pip install pillow --quiet\n",
- "!pip install scikit-image --quiet"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "gKkHjjTGWzUk",
- "metadata": {
- "execution": {},
- "id": "gKkHjjTGWzUk"
- },
- "outputs": [],
- "source": [
- "import glob\n",
- "import json\n",
- "import torch\n",
- "import numpy as np\n",
- "\n",
- "import matplotlib.pyplot as plt\n",
- "from tqdm import tqdm\n",
- "\n",
- "from skimage.io import imread\n",
- "from torchvision.datasets import ImageFolder\n",
- "from torch.utils.data import DataLoader, random_split\n",
- "from torch.utils.data.sampler import WeightedRandomSampler\n",
- "\n",
- "%matplotlib inline"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "bd7d427d",
- "metadata": {
- "execution": {},
- "id": "bd7d427d"
- },
- "source": [
- "---\n",
- "# Project Ideas\n",
- "\n",
- "1. Improve the classifier. This code uses a VGG network for the classification. On the synapse dataset, we will get a validation accuracy of around 80%. Try to see if you can improve the classifier accuracy.\n",
- " * (easy) Data augmentation: The training code for the classifier is quite simple in this example. Enlarge the amount of available training data by adding augmentations (transpose and mirror the images, add noise, change the intensity, etc.).\n",
- " * (easy) Network architecture: The VGG network has a few parameters that one can tune. Try a few to see what difference it makes.\n",
- " * (easy) Inspect the classifier predictions: Take random samples from the test dataset and classify them. Show the images together with their predicted and actual labels.\n",
- " * (medium) Other networks: Try different architectures (e.g., a ResNet) and see if the accuracy can be improved.\n",
- " * (medium) Inspect errors made by the classifier. Which classes are most accurately predicted? Which classes are confused with each other?\n",
- " \n",
- " \n",
- "2. Explore the CycleGAN.\n",
- " * (easy) The example code below shows how to translate between GABA and glutamate. Try different combinations, and also in the reverse direction. Can you start to see differences between some pairs of classes? Which are the ones where the differences are the most or the least obvious?\n",
- " * (hard) Watching the CycleGAN train can be a bit boring. Find a way to show (periodically) the current image and its translation to see how the network is improving over time. Hint: The `cycle_gan` module has a `Visualizer`, which might be helpful.\n",
- " \n",
- "\n",
- "3. Try on your own data!\n",
- " * Have a look at how the synapse images are organized in `data/raw/synapses`. Copy the directory structure and use your own images. Depending on your data, you might have to adjust the image size (128x128 for the synapses) and number of channels in the VGG network and CycleGAN code.\n",
- "\n",
- "### Acknowledgments\n",
- "\n",
- "This notebook was written by Jan Funke, using code from Nils Eckstein and a modified version of the [CycleGAN](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix) implementation.\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5642d709",
- "metadata": {
- "execution": {},
- "id": "5642d709"
- },
- "source": [
- "---\n",
- "# Train an Image Classifier\n",
- "\n",
- "In this section, we will implement and train a VGG classifier to classify images of synapses into one of six classes, corresponding to the neurotransmitter type that is released at the synapse: GABA, acethylcholine, glutamate, octopamine, serotonin, and dopamine."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "c61a11c6",
- "metadata": {
- "execution": {},
- "id": "c61a11c6"
- },
- "source": [
- "## Data Preparation"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "id": "821dc497",
- "metadata": {
- "execution": {},
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "821dc497",
- "outputId": "9871a113-d169-4d6a-b927-b00706fabd22"
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Data downloading...\n",
- "Downloaded: ./part1\n",
- "Downloaded: ./part2\n",
- "Downloaded: ./part3\n",
- "Download is completed.\n",
- "Reassembling Files...\n",
- "Downloaded files have been removed!\n",
- "Reassembled 3 parts into resources.zip\n",
- "Extracting all the files now...\n",
- "Done!\n",
- "\n",
- "Archive: data.zip\n",
- "\tExtracting data...\n",
- "\n",
- "Archive: checkpoints.zip\n",
- "\tExtracting data...\n",
- "Done!\n"
- ]
- }
- ],
- "source": [
- "# @title Download the data\n",
- "import requests, os\n",
- "from zipfile import ZipFile\n",
- "\n",
- "def download_file_parts(urls, output_directory='.'):\n",
- " \"\"\"\n",
- " Download file parts from given URLs and save them in the specified directory.\n",
- "\n",
- " :param urls: List of URLs to download\n",
- " :param output_directory: Directory to save the downloaded parts (default is current directory)\n",
- " :return: List of downloaded file paths\n",
- " \"\"\"\n",
- " if not os.path.exists(output_directory):\n",
- " os.makedirs(output_directory)\n",
- "\n",
- " downloaded_files = []\n",
- "\n",
- " for i, url in enumerate(urls, 1):\n",
- " try:\n",
- " response = requests.get(url, stream=True)\n",
- " response.raise_for_status() # Raises an HTTPError for bad requests\n",
- "\n",
- " file_name = f\"part{i}\"\n",
- " file_path = os.path.join(output_directory, file_name)\n",
- "\n",
- " with open(file_path, 'wb') as file:\n",
- " for chunk in response.iter_content(chunk_size=32768):\n",
- " file.write(chunk)\n",
- "\n",
- " downloaded_files.append(file_path)\n",
- " print(f\"Downloaded: {file_path}\")\n",
- "\n",
- "\n",
- " except requests.RequestException as e:\n",
- " print(f\"Error downloading {url}: {e}\")\n",
- "\n",
- " return downloaded_files\n",
- "\n",
- "def reassemble_file(output_file):\n",
- " chunk_number = 1\n",
- " with open(output_file, 'wb') as outfile:\n",
- " while True:\n",
- " chunk_name = f'part{chunk_number}'\n",
- " if not os.path.exists(chunk_name):\n",
- " break\n",
- " with open(chunk_name, 'rb') as infile:\n",
- " outfile.write(infile.read())\n",
- " chunk_number += 1\n",
- " for i in ['part1', 'part2', 'part3']:\n",
- " if os.path.exists(i):\n",
- " os.remove(i)\n",
- " print(f\"Downloaded files have been removed!\")\n",
- " print(f\"Reassembled {chunk_number-1} parts into {output_file}\")\n",
- "\n",
- "\n",
- "\n",
- "# @markdown Download the resources for this tutorial (one zip file)\n",
- "fname = 'resources.zip'\n",
- "urls = [\n",
- " \"https://osf.io/download/4x7p3/\",\n",
- " \"https://osf.io/download/fzwea/\",\n",
- " \"https://osf.io/download/qpbcv/\"\n",
- "]\n",
- "\n",
- "if not os.path.exists('data/'):\n",
- " print('Data downloading...')\n",
- " output_dir = \".\"\n",
- " downloaded_parts = download_file_parts(urls, output_dir)\n",
- " print('Download is completed.')\n",
- "\n",
- " print('Reassembling Files...')\n",
- " base_name = ''\n",
- " reassemble_file(fname)\n",
- "\n",
- " # @markdown Unzip the file\n",
- " with ZipFile(fname, 'r') as zf:\n",
- " # extracting all the files\n",
- " print('Extracting all the files now...')\n",
- " zf.extractall(path='.')\n",
- " print('Done!')\n",
- "\n",
- " # # @markdown Extract the data\n",
- " fnames = ['data.zip', 'checkpoints.zip']\n",
- "\n",
- " for fname in fnames:\n",
- " with ZipFile(fname, 'r') as zh:\n",
- " # extracting all the files\n",
- " print(f\"\\nArchive: {fname}\")\n",
- " print(f\"\\tExtracting data...\")\n",
- " zh.extractall(path='.')\n",
- " print('Done!')\n",
- "\n",
- " # @markdown Make sure the order of classes matches the pretrained model\n",
- " os.rename('data/raw/synapses/gaba', 'data/raw/synapses/0_gaba')\n",
- " os.rename('data/raw/synapses/acetylcholine', 'data/raw/synapses/1_acetylcholine')\n",
- " os.rename('data/raw/synapses/glutamate', 'data/raw/synapses/2_glutamate')\n",
- " os.rename('data/raw/synapses/serotonin', 'data/raw/synapses/3_serotonin')\n",
- " os.rename('data/raw/synapses/octopamine', 'data/raw/synapses/4_octopamine')\n",
- " os.rename('data/raw/synapses/dopamine', 'data/raw/synapses/5_dopamine')\n",
- "\n",
- " # @markdown Remove the archives\n",
- " for i in ['checkpoints.zip', 'experiments.zip', 'data.zip', 'resources.zip']:\n",
- " if os.path.exists(i):\n",
- " os.remove(i)\n",
- "\n",
- "else:\n",
- " print('Data are already downloaded.')"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0b84ec7b",
- "metadata": {
- "execution": {},
- "id": "0b84ec7b"
- },
- "source": [
- "## Classifier Training"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "a79ab567",
- "metadata": {
- "execution": {},
- "id": "a79ab567"
- },
- "source": [
- "### Create and Inspect Datasets\n",
- "\n",
- "First, we create a `torch` data loaders for training, validation, and testing. We will use weighted sampling to account for the class imbalance during training."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "id": "ae50b16a",
- "metadata": {
- "execution": {},
- "id": "ae50b16a",
- "outputId": "e92b100a-6711-4369-c025-6a0e10fbbdb6",
- "colab": {
- "base_uri": "https://localhost:8080/"
- }
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Number of images per class:\n",
- "\t0_gaba:\tn=15855\tweight=6.30715862503942e-05\n",
- "\t1_acetylcholine:\tn=4911\tweight=0.00020362451639177357\n",
- "\t2_glutamate:\tn=3550\tweight=0.00028169014084507044\n",
- "\t3_serotonin:\tn=2297\tweight=0.00043535045711797995\n",
- "\t4_octopamine:\tn=951\tweight=0.0010515247108307045\n",
- "\t5_dopamine:\tn=4649\tweight=0.00021510002151000216\n"
- ]
- }
- ],
- "source": [
- "def load_image(filename):\n",
- "\n",
- " image = imread(filename)\n",
- "\n",
- " # images are grescale, we only need one of the RGB channels\n",
- " image = image[:, :, 0]\n",
- " # img is uint8 in [0, 255], but we want float32 in [-1, 1]\n",
- " image = image.astype(np.float32)/255.0\n",
- " image = (image - 0.5)/0.5\n",
- "\n",
- " return image\n",
- "\n",
- "\n",
- "# create a dataset for all images of all classes\n",
- "full_dataset = ImageFolder(root='data/raw/synapses', loader=load_image)\n",
- "\n",
- "# randomly split the dataset into train, validation, and test\n",
- "num_images = len(full_dataset)\n",
- "# ~70% for training\n",
- "num_training = int(0.7 * num_images)\n",
- "# ~15% for validation\n",
- "num_validation = int(0.15 * num_images)\n",
- "# ~15% for testing\n",
- "num_test = num_images - (num_training + num_validation)\n",
- "# split the data randomly (but with a fixed random seed)\n",
- "train_dataset, validation_dataset, test_dataset = random_split(\n",
- " full_dataset,\n",
- " [num_training, num_validation, num_test],\n",
- " generator=torch.Generator().manual_seed(23061912))\n",
- "\n",
- "# compute class weights in training dataset for uniform sampling\n",
- "ys = np.array([y for _, y in train_dataset])\n",
- "counts = np.bincount(ys)\n",
- "label_weights = 1.0 / counts\n",
- "weights = label_weights[ys]\n",
- "\n",
- "print(\"Number of images per class:\")\n",
- "for c, n, w in zip(full_dataset.classes, counts, label_weights):\n",
- " print(f\"\\t{c}:\\tn={n}\\tweight={w}\")\n",
- "\n",
- "# create a data loader with uniform sampling\n",
- "sampler = WeightedRandomSampler(weights, len(weights))\n",
- "# this data loader will serve 8 images in a \"mini-batch\" at a time\n",
- "dataloader = DataLoader(train_dataset, batch_size=8, drop_last=True, sampler=sampler)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "e9010bdc",
- "metadata": {
- "execution": {},
- "id": "e9010bdc"
- },
- "source": [
- "The cell below visualizes a single, randomly chosen batch from the training data loader. Feel free to execute this cell multiple times to get a feeling for the dataset. See if you can tell the difference between synapses of different types!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "id": "3d8c6f3a",
- "metadata": {
- "execution": {},
- "id": "3d8c6f3a",
- "outputId": "5d4a01f7-aa52-4e35-b6a6-a7950779dd3d",
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 117
- }
- },
- "outputs": [
- {
- "output_type": "display_data",
- "data": {
- "text/plain": [
- "![](\"https://raw.githubusercontent.com/NeuromatchAcademy/course-content-dl/main/projects/static/lunar_lander.png\")
"
- ]
- },
- {
- "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"
- ]
- }
- ],
- "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": {},
- "id": "EHLx2d5xDBuV"
- },
- "source": [
- "Now, let us setup our model and the DQN algorithm."
- ]
- },
- {
- "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\"."
- ]
- },
- {
- "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)."
- ]
- },
- {
- "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)"
- ]
- },
- {
- "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: