{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "kzN-Q9Zv1He1" }, "source": [ "# DQN\n", "\n", "The goal of this exercise is to implement DQN and to apply it to the cartpole balancing problem. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "try:\n", " import google.colab\n", " IN_COLAB = True\n", "except:\n", " IN_COLAB = False\n", "\n", "if IN_COLAB:\n", " !pip install -U gymnasium pygame moviepy\n", " !pip install gymnasium[box2d]" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ZuVpP0LaxKM5", "outputId": "948030f3-cdfb-43a1-882a-6140df11639b" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "gym version: 0.26.3\n" ] } ], "source": [ "import numpy as np\n", "rng = np.random.default_rng()\n", "import matplotlib.pyplot as plt\n", "import os\n", "from IPython.display import clear_output\n", "from collections import deque\n", "\n", "import gymnasium as gym\n", "print(\"gym version:\", gym.__version__)\n", "\n", "import pygame\n", "from moviepy.editor import ImageSequenceClip, ipython_display\n", "\n", "import tensorflow as tf\n", "import logging\n", "tf.get_logger().setLevel(logging.ERROR)\n", "\n", "class GymRecorder(object):\n", " \"\"\"\n", " Simple wrapper over moviepy to generate a .gif with the frames of a gym environment.\n", " \n", " The environment must have the render_mode rgb_array_list.\n", " \"\"\"\n", " def __init__(self, env):\n", " self.env = env\n", " self._frames = []\n", "\n", " def record(self, frames):\n", " \"To be called at the end of an episode.\"\n", " for frame in frames:\n", " self._frames.append(np.array(frame))\n", "\n", " def make_video(self, filename):\n", " \"Generates the gif video.\"\n", " directory = os.path.dirname(os.path.abspath(filename))\n", " if not os.path.exists(directory):\n", " os.mkdir(directory)\n", " self.clip = ImageSequenceClip(list(self._frames), fps=self.env.metadata[\"render_fps\"])\n", " self.clip.write_gif(filename, fps=self.env.metadata[\"render_fps\"], loop=0)\n", " del self._frames\n", " self._frames = []\n", "\n", "def running_average(x, N):\n", " kernel = np.ones(N) / N\n", " return np.convolve(x, kernel, mode='same')" ] }, { "cell_type": "markdown", "metadata": { "id": "EPakRvKRoA79" }, "source": [ "## Cartpole balancing task\n", "\n", "We are going to use the Cartpole balancing problem, which can be loaded with:\n", "\n", "python\n", "gym.make('CartPole-v0')\n", "\n", "\n", "States have 4 continuous values (position and speed of the cart, angle and speed of the pole) and 2 discrete outputs (going left or right). The reward is +1 for each transition where the pole is still standing (angle of less than 30° with the vertical). \n", "\n", "In CartPole-v0, the episode ends when the pole fails or after 200 steps. In CartPole-v1, the maximum episode length is 500 steps, which is too long for us, so we stick to v0 here.\n", "\n", "The maximal (undiscounted) return is therefore 200. Can DQN learn this?" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 438 }, "id": "zBkpg0MDoIxJ", "outputId": "58411c0e-4248-4e15-9f5e-b284aeea321e" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Return: 19.0\n", "MoviePy - Building file videos/cartpole.gif with imageio.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " \r" ] }, { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create the environment\n", "env = gym.make('CartPole-v0', render_mode=\"rgb_array_list\")\n", "recorder = GymRecorder(env)\n", "\n", "# Sample the initial state\n", "state, info = env.reset()\n", "\n", "# One episode:\n", "done = False\n", "return_episode = 0\n", "while not done:\n", "\n", " # Select an action randomly\n", " action = env.action_space.sample()\n", " \n", " # Sample a single transition\n", " next_state, reward, terminal, truncated, info = env.step(action)\n", "\n", " # End of the episode\n", " done = terminal or truncated\n", "\n", " # Update undiscounted return\n", " return_episode += reward\n", " \n", " # Go in the next state\n", " state = next_state\n", "\n", "print(\"Return:\", return_episode)\n", "\n", "recorder.record(env.render())\n", "video = \"videos/cartpole.gif\"\n", "recorder.make_video(video)\n", "ipython_display(video)" ] }, { "cell_type": "markdown", "metadata": { "id": "_3CIDqP41Wvf" }, "source": [ "As the problem is quite simple (4 state variables, 2 actions), DQN can run on a single CPU. However, we advise that you run the notebook on a GPU in Colab to avoid emptying the battery of your laptop too fast or making it too warm as training takes quite a long time.\n", "\n", "We will stop from now on to display the cartpole on colab, as we want to go fast." ] }, { "cell_type": "markdown", "metadata": { "id": "8hEvKXD1LDCq" }, "source": [ "## Creating the model\n", "\n", "The first step is to create the value network using keras. We will not need anything fancy: a simple fully connected network with 4 input neurons, two hidden layers of 64 neurons each and 2 output neurons will do the trick. ReLU activation functions all along and the Adam optimizer.\n", "\n", "**Q:** Which loss function should we use? Think about which arguments have to passed to model.compile() and what activation function is required in the output layer.\n", "\n", "We will need to create two identical networks: the trained network and the target network. You should therefore create a method that returns a compiled model, so it can be called two times. You should pass it the environment (so the network can know how many input and output neurons it needs) and the learning rate for the Adam optimizer.\n", "\n", "python\n", "def create_model(env, lr):\n", " \n", " model = Sequential()\n", "\n", " # ...\n", "\n", " return model\n", "\n", "\n", "**Q:** Implement the method accordingly." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "h67ZdBDZ6PKL" }, "outputs": [], "source": [ "def create_model(env, lr):\n", " \n", " model = tf.keras.models.Sequential()\n", " \n", " model.add(tf.keras.layers.Input(env.observation_space.shape))\n", " model.add(tf.keras.layers.Dense(64, activation='relu'))\n", " model.add(tf.keras.layers.Dense(64, activation='relu'))\n", " model.add(tf.keras.layers.Dense(env.action_space.n, activation='linear'))\n", " \n", " model.compile(loss='mse', optimizer=tf.keras.optimizers.Adam(learning_rate=lr))\n", " \n", " print(model.summary())\n", "\n", " return model" ] }, { "cell_type": "markdown", "metadata": { "id": "UF4OBQRtOpZZ" }, "source": [ "Let's test this method by creating the trained and target networks.\n", "\n", "**Important:** every time you call create_model, a new neural network will be instantiated but the previous ones will not be deleted. During this exercise, you may have to create hundreds of networks because of the incremental implementation of DQN: all networks will stay instantiated in the RAM, and your computer/colab tab will freeze after a while. Before creating new networks, delete all existing ones with:\n", "\n", "python\n", "tf.keras.backend.clear_session()\n", "\n", "\n", "**Q:** Create the trained and target networks. The learning rate does not matter for now. Instantiate the Cartpole environment and print the output of both networks for the initial state (state, info = env.reset()). Are they the same?\n", "\n", "*Hint:* model.predict(X, verbose=0) expects an array X of shape (N, 4), with N the number of examples. Here, we have only one example, so make sure to reshape state so it has the shape (1, 4) (otherwise tf will complain)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "IywqFrVTOq8N", "outputId": "5298b903-b14b-4136-d8db-16c74b321199" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "State: [[0.01271655 0.00693787 0.00868186 0.00911883]]\n", "Metal device set to: Apple M1 Pro\n", "Model: \"sequential\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " dense (Dense) (None, 64) 320 \n", " \n", " dense_1 (Dense) (None, 64) 4160 \n", " \n", " dense_2 (Dense) (None, 2) 130 \n", " \n", "=================================================================\n", "Total params: 4,610\n", "Trainable params: 4,610\n", "Non-trainable params: 0\n", "_________________________________________________________________\n", "None\n", "Model: \"sequential_1\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " dense_3 (Dense) (None, 64) 320 \n", " \n", " dense_4 (Dense) (None, 64) 4160 \n", " \n", " dense_5 (Dense) (None, 2) 130 \n", " \n", "=================================================================\n", "Total params: 4,610\n", "Trainable params: 4,610\n", "Non-trainable params: 0\n", "_________________________________________________________________\n", "None\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-11-25 11:15:13.944109: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:306] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n", "2022-11-25 11:15:13.944323: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:272] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: )\n", "2022-11-25 11:15:14.117562: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n", "2022-11-25 11:15:14.148074: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "----------\n", "State: [[0.01271655 0.00693787 0.00868186 0.00911883]]\n", "Prediction for the trained network: [0.00114096 0.00075357]\n", "Prediciton for the target network: [-0.00087994 0.00059144]\n", "----------\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-11-25 11:15:14.260500: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n" ] } ], "source": [ "env = gym.make('CartPole-v0')\n", "\n", "state, info = env.reset()\n", "state = state.reshape((1, env.observation_space.shape[0]))\n", "print(\"State:\", state)\n", "\n", "tf.keras.backend.clear_session()\n", "trained_model = create_model(env, 0.001)\n", "target_model = create_model(env, 0.001)\n", "\n", "trained_prediction = trained_model.predict(state, verbose=0)[0]\n", "target_prediction = target_model.predict(state, verbose=0)[0]\n", "\n", "print('-'*10)\n", "print(\"State:\", state)\n", "print(\"Prediction for the trained network:\", trained_prediction)\n", "print(\"Prediciton for the target network:\", target_prediction)\n", "print('-'*10)" ] }, { "cell_type": "markdown", "metadata": { "id": "lJ5sZzqfQ2MK" }, "source": [ "The target network has the same structure as the trained network, but not the same weights, as they are randomly initialized. We want the target network $\\theta'$ to have exactly the same weights as the trained weights $\\theta$. You can obtain the weights of a network with:\n", "\n", "python\n", "w = model.get_weights()\n", "\n", "\n", "and set weights using:\n", "\n", "python\n", "model.set_weights(w)\n", "\n", "\n", "**Q:** Transfer the weights of the trained model to the target model. Compare their predictions for the current state." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "VI9b0cmZQ2mr", "outputId": "48ea740d-9abd-4d88-942c-f895c27baa25" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "----------\n", "State: [[0.01271655 0.00693787 0.00868186 0.00911883]]\n", "Prediction for the trained network: [0.00114096 0.00075357]\n", "Prediciton for the target network: [0.00114096 0.00075357]\n", "----------\n" ] } ], "source": [ "target_model.set_weights(trained_model.get_weights())\n", "\n", "trained_prediction = trained_model.predict(state, verbose=0)[0]\n", "target_prediction = target_model.predict(state, verbose=0)[0]\n", "\n", "print('-'*10)\n", "print(\"State:\", state)\n", "print(\"Prediction for the trained network:\", trained_prediction)\n", "print(\"Prediciton for the target network:\", target_prediction)\n", "print('-'*10)" ] }, { "cell_type": "markdown", "metadata": { "id": "FUEWBYwUOpxm" }, "source": [ "## Experience replay memory\n", "\n", "The second thing that we need is the experience replay memory (or replay buffer). We need a container like a python list where we append (s, a, r, s', done) transitions (as in Q-learning), but with a maximal capacity: when there are already $C$ transitions in the list, one should stop appending to the list, but rather start writing at the beginning of the list.\n", "\n", "This would not be very hard to write, but it would take a lot of time and the risk is high to have hard-to-notice bugs. \n", "\n", "Here is a basic implementation of the replay buffer using **double-ended queues** (deque). A deque is list with a maximum capacity. If the deque is full, it starts writing again at the beginnning. Exactly what we need. This implementation uses one deque per element in (s, a, r, s', done), but one could also append the whole transition to a single deque.\n", "\n", "**Q:** Read the code of the ReplayBuffer and understand what it does." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "hf-CRYjS6PKO" }, "outputs": [], "source": [ "class ReplayBuffer:\n", " \"Basic implementation of the experience replay memory using separated deques.\"\n", " def __init__(self, max_capacity):\n", " self.max_capacity = max_capacity\n", " \n", " # deques for each element\n", " self.states = deque(maxlen=max_capacity)\n", " self.actions = deque(maxlen=max_capacity)\n", " self.rewards = deque(maxlen=max_capacity)\n", " self.next_states = deque(maxlen=max_capacity)\n", " self.dones = deque(maxlen=max_capacity)\n", " \n", " def append(self, state, action, reward, next_state, done):\n", " # Store data\n", " self.states.append(state)\n", " self.actions.append(action)\n", " self.rewards.append(reward)\n", " self.next_states.append(next_state)\n", " self.dones.append(done)\n", " \n", " def sample(self, batch_size):\n", " # Do not return samples if we do not have at least 2*batch_size transitions\n", " if len(self.states) < 2*batch_size: \n", " return []\n", " \n", " # Randomly choose the indices of the samples.\n", " indices = sorted(np.random.choice(np.arange(len(self.states)), batch_size, replace=False))\n", "\n", " # Return the corresponding\n", " return [np.array([self.states[i] for i in indices]), \n", " np.array([self.actions[i] for i in indices]), \n", " np.array([self.rewards[i] for i in indices]), \n", " np.array([self.next_states[i] for i in indices]), \n", " np.array([self.dones[i] for i in indices])]" ] }, { "cell_type": "markdown", "metadata": { "id": "CjmNxom5eftK" }, "source": [ "**Q:** Run a random agent on Cartpole (without rendering) for a few episodes and append each transition to a replay buffer with small capacity (e.g. 100). Sample a batch to check that everything makes sense." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ajn1ht1dco5N", "outputId": "d95112be-68f0-4681-e354-72625f656b75" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "States: [[-7.1889226e-05 -1.9597625e-02 1.1202861e-02 1.0221607e-02]\n", " [-5.1598279e-03 -2.1528986e-01 1.7882740e-02 3.1551802e-01]\n", " [-7.8443229e-02 -8.0612069e-01 1.3144340e-01 1.3234164e+00]\n", " [-4.6816234e-02 2.0717475e-01 4.1258741e-02 -2.8127652e-01]\n", " [-4.2442955e-02 -1.8412507e-01 3.6115777e-02 3.2783771e-01]\n", " [-9.1748878e-02 -3.8812301e-01 1.3098954e-01 8.2237107e-01]\n", " [ 7.3674910e-02 6.0291737e-01 -7.6641589e-02 -8.1436384e-01]\n", " [ 8.5733257e-02 7.9900050e-01 -9.2928864e-02 -1.1301358e+00]\n", " [ 1.2985145e-01 6.0852367e-01 -1.5678419e-01 -9.4639248e-01]\n", " [ 1.5025000e-02 7.9516947e-01 -4.6248329e-03 -1.1131814e+00]]\n", "Actions: [0 0 1 0 0 0 1 0 0 1]\n", "Rewards: [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", "Next states: [[-4.6384174e-04 -2.1487844e-01 1.1407293e-02 3.0641800e-01]\n", " [-9.4656255e-03 -4.1066191e-01 2.4193101e-02 6.1378646e-01]\n", " [-9.4565637e-02 -6.1288112e-01 1.5791173e-01 1.0745906e+00]\n", " [-4.2672738e-02 1.1489304e-02 3.5633210e-02 2.4128472e-02]\n", " [-4.6125453e-02 -3.7974206e-01 4.2672534e-02 6.3168758e-01]\n", " [-9.9511340e-02 -5.8477044e-01 1.4743695e-01 1.1532161e+00]\n", " [ 8.5733257e-02 7.9900050e-01 -9.2928864e-02 -1.1301358e+00]\n", " [ 1.0171327e-01 6.0521013e-01 -1.1553158e-01 -8.6798614e-01]\n", " [ 1.4202191e-01 4.1582093e-01 -1.7571205e-01 -7.0678967e-01]\n", " [ 3.0928390e-02 9.9035186e-01 -2.6888460e-02 -1.4073114e+00]]\n", "Dones: [False False False False False False False False False False]\n" ] } ], "source": [ "env = gym.make('CartPole-v0')\n", "\n", "buffer = ReplayBuffer(100)\n", "\n", "for episode in range(10):\n", " \n", " # Reset\n", " state, info = env.reset()\n", " done = False\n", " \n", " # Sample the episode\n", " while not done:\n", " \n", " # Select an action randomly\n", " action = env.action_space.sample()\n", " \n", " # Perform the action\n", " next_state, reward, terminal, truncated, info = env.step(action)\n", "\n", " # End of the episode\n", " done = terminal or truncated\n", " \n", " # Store the transition\n", " buffer.append(state, action, reward, next_state, done)\n", " \n", " # Go in the next state\n", " state = next_state\n", " \n", "# Sample a minibatch\n", "batch = buffer.sample(10)\n", "print(\"States:\", batch[0])\n", "print(\"Actions:\", batch[1])\n", "print(\"Rewards:\", batch[2])\n", "print(\"Next states:\", batch[3])\n", "print(\"Dones:\", batch[4])" ] }, { "cell_type": "markdown", "metadata": { "id": "u29Tw9o6fRcw" }, "source": [ "## DQN agent\n", "\n", "Here starts the fun part. There are a lot of things to do here, but you will now whether it works or not only when everything has been (correctly) implemented. So here is a lot of text to read carefully, and then you are on your own.\n", "\n", "Reminder from the lecture:\n", "\n", "* Initialize value network $Q_{\\theta}$ and target network $Q_{\\theta'}$.\n", "\n", "* Initialize experience replay memory $\\mathcal{D}$ of maximal size $N$.\n", "\n", "* for $t \\in [0, T_\\text{total}]$:\n", "\n", " * Select an action $a_t$ based on $Q_\\theta(s_t, a)$, observe $s_{t+1}$ and $r_{t+1}$.\n", "\n", " * Store $(s_t, a_t, r_{t+1}, s_{t+1})$ in the experience replay memory.\n", "\n", " * Every $T_\\text{train}$ steps:\n", "\n", " * Sample a minibatch $\\mathcal{D}_s$ randomly from $\\mathcal{D}$.\n", "\n", " * For each transition $(s_k, a_k, r_k, s'_k)$ in the minibatch:\n", "\n", " * Compute the target value $t_k = r_k + \\gamma \\, \\max_{a'} Q_{\\theta'}(s'_k, a')$ using the target network.\n", "\n", " * Update the value network $Q_{\\theta}$ on $\\mathcal{D}_s$ to minimize:\n", "\n", " $$\\mathcal{L}(\\theta) = \\mathbb{E}_{\\mathcal{D}_s}[(t_k - Q_\\theta(s_k, a_k))^2]$$\n", "\n", " * Every $T_\\text{target}$ steps:\n", "\n", " * Update target network: $\\theta' \\leftarrow \\theta$.\n", "\n", "Here is the skeleton of the DQNAgent class that you have to write:\n", "\n", "python\n", "class DQNAgent:\n", " \n", " def __init__(self, env, create_model, some_parameters):\n", " \n", " self.env = env\n", " \n", " # TODO: copy the parameters\n", "\n", " # TODO: Create the trained and target networks, copy the weights.\n", "\n", " # TODO: Create an instance of the replay memory\n", " \n", " def act(self, state):\n", "\n", " # TODO: Select an action using epsilon-greedy on the output of the trained model\n", "\n", " return action\n", " \n", " def update(self, batch):\n", " \n", " # TODO: train the model using the batch of transitions\n", " \n", " return loss # mse on the batch\n", "\n", " def train(self, nb_episodes):\n", "\n", " returns = []\n", " losses = []\n", "\n", " # TODO: Train the network for the given number of episodes\n", "\n", " return returns, losses\n", "\n", " def test(self):\n", "\n", " # TODO: one episode with epsilon temporarily set to 0\n", "\n", " return nb_steps # Should be 200 after learning\n", "\n", "\n", "With this structure, it will be very simple to actually train the DQN on Cartpole:\n", "\n", "python\n", "# Create the environment\n", "env = gym.make('CartPole-v1')\n", "\n", "# Create the agent\n", "agent = DQNAgent(env, create_model, other_parameters)\n", "\n", "# Train the agent\n", "returns, losses = agent.train(nb_episodes)\n", "\n", "# Plot the returns\n", "plt.figure(figsize=(10, 6))\n", "plt.plot(returns)\n", "plt.plot(running_mean(returns, 10))\n", "plt.xlabel(\"Episodes\")\n", "plt.ylabel(\"Returns\")\n", "\n", "# Plot the losses\n", "plt.figure(figsize=(10, 6))\n", "plt.plot(losses)\n", "plt.xlabel(\"Episodes\")\n", "plt.ylabel(\"Training loss\")\n", "\n", "plt.show()\n", "\n", "# Test the network\n", "nb_steps = agent.test()\n", "print(\"Number of steps:\", nb_steps)\n", "\n", "\n", "So you \"just\" have to fill the holes.\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "4xwVaGiAif8G" }, "source": [ "### 1 - __init__(): Initializing the agent\n", "\n", "In this method, you should first copy the value of the parameters as attributes: learning rate, epsilon, gamma and so on.\n", "\n", "Suggested values: gamma = 0.99, learning_rate = 0.001 \n", "\n", "The second thing to do is to create the trained and target networks (with the same weights) and save them as attributes (the other methods will use them). Do not forget to clear the keras session first, otherwise the RAM will be quickly filled.\n", "\n", "The third thing is to create an instance of the ERM. Use a buffer limit of 5000 transitions (should be passed as a parameter). \n", "\n", "Do not hesitate to add other stuff as you implementing the other methods (e.g. counters)." ] }, { "cell_type": "markdown", "metadata": { "id": "jULjJ-EqkBuU" }, "source": [ "### 2 - act(): action selection\n", "\n", "We will use a simple $\\epsilon$-greedy method for the action selection, as in the previous exercises. \n", "\n", "The only difference is that we have to use the trained model to get the greedy action, using trained_model.predict(X, verbose=0). This will return the Q-value of the two actions left and right. Use argmax() to return the greedy action (with probability 1 - $\\epsilon$). env.action_space.sample() should be used for the exploration (do not use the Q-network in that case, it is slow!).\n", "\n", "$\\epsilon$ will be scheduled with an initial value of 1.0 and an exponential decay rate of 0.0005 after each action. It is always better to keep a little exploration, even if $\\epsilon$ has decayed to 0. Keep a minimal value of 0.05 for epsilon. \n", "\n", "**Q:** Once this has been implemented, run your very slow random agent for 100 episodes to check everything works correctly." ] }, { "cell_type": "markdown", "metadata": { "id": "spNME6LFtWFb" }, "source": [ "### 3 - train(): training loop\n", "\n", "This method will be very similar to the Q-learning agent that you implemented previously. Do not hesitate to copy and paste.\n", "\n", "Here is the parts of the DQN algorithm that should be implemented:\n", "\n", "* for $t \\in [0, T_\\text{total}]$:\n", "\n", " * Select an action $a_t$ based on $Q_\\theta(s_t, a)$, observe $s_{t+1}$ and $r_{t+1}$.\n", "\n", " * Store $(s_t, a_t, r_{t+1}, s_{t+1})$ in the experience replay memory.\n", "\n", " * Every $T_\\text{train}$ steps:\n", "\n", " * Sample a minibatch $\\mathcal{D}_s$ randomly from $\\mathcal{D}$.\n", "\n", " * Update the trained network using $\\mathcal{D}_s$.\n", "\n", " * Every $T_\\text{target}$ steps:\n", "\n", " * Update target network: $\\theta' \\leftarrow \\theta$.\n", "\n", "The main difference with Q-learning is that update() will be called only every T_train = 4 steps: the number of updates to the trained network will be 4 times smaller that the number of steps made in the environment. Beware that if the ERM does not have enough transitions yet (less than the batch size), you should not call update().\n", "\n", "Updating the target network (copying the weights of the trained network) should happen every 100 steps. Pass these parameters to the constructor of the agent. \n", "\n", "The batch size can be set to 32." ] }, { "cell_type": "markdown", "metadata": { "id": "nAsS8V4NwAua" }, "source": [ "### 4 - update(): training the value network\n", "\n", "Using the provided minibatch, one should implement the following part of the DQN algorithm:\n", "\n", "* For each transition $(s_k, a_k, r_k, s'_k)$ in the minibatch:\n", "\n", " * Compute the target value $t_k = r_k + \\gamma \\, \\max_{a'} Q_{\\theta'}(s'_k, a')$ using the target network.\n", "\n", "* Update the value network $Q_{\\theta}$ on $\\mathcal{D}_s$ to minimize:\n", "\n", " $$\\mathcal{L}(\\theta) = \\mathbb{E}_{\\mathcal{D}_s}[(t_k - Q_\\theta(s_k, a_k))^2]$$\n", "\n", "So we just need to define the targets for each transition in the minibatch, and call model.fit() on the trained network to minimize the mse between the current predictions $Q_\\theta(s_k, a_k)$ and the target.\n", "\n", "But we have a problem: the network has two outputs for the actions left and right, but we have only one target for the action that was executed. We cannot compute the mse between a vector with 2 elements and a single value... They must have the same size.\n", "\n", "As we want only the train the output neuron corresponding to the action $a_k$, we are going to:\n", "\n", "1. Use the trained network to predict the Q-value of both actions $[Q_\\theta(s_k, 0), Q_\\theta(s_k, 1)]$.\n", "2. Replace one of the values with the target, for example $[Q_\\theta(s_k, 0), t_k]$ if the second action was chosen.\n", "3. Minimize the mse between $[Q_\\theta(s_k, 0), Q_\\theta(s_k, 1)]$ and $[Q_\\theta(s_k, 0), t_k]$.\n", "\n", "That way, the first output neuron has a squared error of 0, so it won't learn anything. Only the second output neuron will have a non-zero mse and learn.\n", "\n", "There are more efficient ways to do this (using masks), but this will do the trick, the drawback being that we have to make a forward pass on the minibatch before calling fit().\n", "\n", "The rest is pretty much the same as for your Q-learning agent. Do not forget that actions leading to a terminal state should only use the reward as a target, not the complete Bellman target $r + \\gamma \\max Q$.\n", "\n", "*Hint:* as we sample a minibatch of 32 transitions, it is faster to call:\n", "\n", "python\n", "Q_values = np.array(training_model.predict_on_batch(states))\n", "\n", "\n", "than:\n", "\n", "python\n", "Q_values = training_model.predict(states)\n", "\n", "\n", "for reasons internal to tensorflow. Note that with tf2, you need to cast the result to numpy arrays as eager mode is now the default.\n", "\n", "The method should return the training loss, which is contained in the History object returned by model.fit(). model.fit() should be called for one epoch only, a batch size of 32, and verbose set to 0. " ] }, { "cell_type": "markdown", "metadata": { "id": "ym9zpNaK-wxl" }, "source": [ "### 5 - test()\n", "\n", "This method should run one episode with epsilon set to 0, without learning. The number of steps should be returned (do not bother discounting with gamma, the goal is to be up for 200 steps). " ] }, { "cell_type": "markdown", "metadata": { "id": "gmEoNa1V_d7l" }, "source": [ "**Q:** Let's go! Run the agent for 150 episodes and observe how fast it manages to keep the pole up for 200 steps. \n", "\n", "Beware that running the same network twice can lead to very different results. In particular, policy collapse (the network was almost perfect, but suddenly crashes and becomes random) can happen. Just be patient. \n", "\n", "You can visualize a test trial using the GymRecorder: you just need to set the env attribute of your DQN agent to a new env with the render mode rgb_array_list and record the frames at the end." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "kkUo7qS26PKS" }, "outputs": [], "source": [ "class DQNAgent:\n", " \n", " def __init__(self, env, create_model, learning_rate, epsilon, epsilon_decay, gamma, batch_size, target_update_period, training_update_period, buffer_limit):\n", " self.env = env\n", "\n", " self.learning_rate = learning_rate\n", " self.epsilon = epsilon\n", " self.epsilon_decay = epsilon_decay\n", " self.gamma = gamma\n", " self.batch_size = batch_size\n", " self.target_update_period = target_update_period\n", " self.training_update_period = training_update_period\n", " \n", " # Create the Q-network and the target network\n", " tf.keras.backend.clear_session() # start by deleting all existing models to be gentle on the RAM\n", " self.model = create_model(self.env, self.learning_rate)\n", " self.target_model = create_model(self.env, self.learning_rate)\n", " self.target_model.set_weights(self.model.get_weights())\n", "\n", " # Create the replay memory\n", " self.buffer = ReplayBuffer(buffer_limit)\n", " \n", " def act(self, state):\n", "\n", " # epsilon-greedy\n", " if np.random.rand() < self.epsilon: # Random selection\n", " action = self.env.action_space.sample()\n", " else: # Use the Q-network to get the greedy action\n", " action = self.model.predict(state.reshape((1, env.observation_space.shape[0])), verbose=0)[0].argmax()\n", "\n", " # Decay epsilon\n", " self.epsilon *= 1 - self.epsilon_decay\n", " self.epsilon = max(0.05, self.epsilon)\n", "\n", " return action\n", " \n", " def update(self, batch):\n", " \n", " # Get the minibatch\n", " states, actions, rewards, next_states, dones = batch \n", " \n", " # Predict the Q-values in the current state\n", " targets = np.array(self.model.predict_on_batch(states))\n", " \n", " # Predict the Q-values in the next state using the target model\n", " next_Q_value = np.array(self.target_model.predict_on_batch(next_states)).max(axis=1)\n", " \n", " # Terminal states have a value of 0\n", " next_Q_value[dones] = 0.0\n", " \n", " # Compute the target\n", " for i in range(self.batch_size):\n", " targets[i, actions[i]] = rewards[i] + self.gamma * next_Q_value[i]\n", " \n", " # Train the model on the minibatch\n", " history = self.model.fit(states, targets, epochs=1, batch_size=self.batch_size, verbose=0)\n", " \n", " return history.history['loss'][0]\n", "\n", " def train(self, nb_episodes):\n", "\n", " steps = 0\n", " returns = []\n", " losses = []\n", "\n", " for episode in range(nb_episodes):\n", " \n", " # Reset\n", " state, info = self.env.reset()\n", " done = False\n", " steps_episode = 0\n", " return_episode = 0\n", "\n", " loss_episode = []\n", " \n", " # Sample the episode\n", " while not done:\n", "\n", " # Select an action \n", " action = self.act(state)\n", " \n", " # Perform the action\n", " next_state, reward, terminal, truncated, info = self.env.step(action)\n", "\n", " # End of the episode\n", " done = terminal or truncated\n", " \n", " # Store the transition\n", " self.buffer.append(state, action, reward, next_state, done)\n", " \n", " # Sample a minibatch\n", " batch = self.buffer.sample(self.batch_size)\n", " \n", " # Train the NN on the minibatch\n", " if len(batch) > 0 and steps % self.training_update_period == 0:\n", " loss = self.update(batch)\n", " loss_episode.append(loss)\n", "\n", " # Update the target model\n", " if steps > self.target_update_period and steps % self.target_update_period == 0:\n", " self.target_model.set_weights(self.model.get_weights())\n", " \n", " # Go in the next state\n", " state = next_state\n", " \n", " # Increment time\n", " steps += 1\n", " steps_episode += 1\n", " return_episode += reward\n", " \n", " if done:\n", " break\n", " \n", " # Store info\n", " returns.append(return_episode)\n", " losses.append(np.mean(loss_episode))\n", "\n", " # Print info\n", " clear_output(wait=True)\n", " print('Episode', episode+1)\n", " print(' total steps:', steps)\n", " print(' length of the episode:', steps_episode)\n", " print(' return of the episode:', return_episode)\n", " print(' current loss:', np.mean(loss_episode))\n", " print(' epsilon:', self.epsilon)\n", "\n", " return returns, losses\n", "\n", " def test(self, render=True):\n", "\n", " old_epsilon = self.epsilon\n", " self.epsilon = 0.0\n", " \n", " state, info = self.env.reset()\n", " nb_steps = 0\n", " done = False\n", " \n", " while not done:\n", " action = self.act(state)\n", " next_state, reward, terminal, truncated, info = self.env.step(action)\n", " done = terminal or truncated\n", " state = next_state\n", " nb_steps += 1\n", " \n", " self.epsilon = old_epsilon\n", " return nb_steps\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "id": "-X9trhsf6PKV" }, "outputs": [], "source": [ "# Parameters\n", "nb_episodes = 150\n", "batch_size = 32\n", "\n", "epsilon = 1.0\n", "epsilon_decay = 0.0005\n", "\n", "gamma = 0.99\n", "\n", "learning_rate = 0.005 \n", "buffer_limit = 5000\n", "target_update_period = 100\n", "training_update_period = 4" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 865 }, "id": "das8K2JL6PKc", "outputId": "d920d07f-198c-4591-d6c3-2945fea5c287" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Episode 150\n", " total steps: 17021\n", " length of the episode: 138\n", " return of the episode: 138.0\n", " current loss: 7.081971720286778\n", " epsilon: 0.05\n" ] }, { "data": { "image/png": "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", "text/plain": [ "