{ "cells": [ { "cell_type": "markdown", "source": [ "Some imports just to render the results in colab" ], "metadata": { "id": "DvGm0V_AWiEw" } }, { "cell_type": "code", "source": [ "!pip install gymnasium" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "m3Fcej5GUnbX", "outputId": "f5e15855-1e2f-4b06-fb41-cc86007d0f93" }, "execution_count": 1, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Requirement already satisfied: gymnasium in /usr/local/lib/python3.10/dist-packages (0.29.1)\n", "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (1.25.2)\n", "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (2.2.1)\n", "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (4.10.0)\n", "Requirement already satisfied: farama-notifications>=0.0.1 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (0.0.4)\n" ] } ] }, { "cell_type": "code", "source": [ "from gymnasium.wrappers import RecordVideo\n", "import glob\n", "import io\n", "import base64\n", "from IPython.display import HTML\n", "from IPython import display\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", "\n", "def show_video():\n", " mp4list = glob.glob('video/*.mp4')\n", " if len(mp4list) > 0:\n", " mp4 = mp4list[0]\n", " video = io.open(mp4, 'r+b').read()\n", " encoded = base64.b64encode(video)\n", " display.display(HTML(data=''''''.format(encoded.decode('ascii'))))\n", " else:\n", " print(\"Could not find video\")" ], "metadata": { "id": "Q5PGqOlHWjC5" }, "execution_count": 2, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "ATzH4Ql0Lhvo" }, "source": [ "# Function Approximation (1)\n", "## Tile Coding in the Mountain Car problem\n", "\n", "In this notebook we will show benefits of FA in the Mountain Car problem\n", "\n", "The Goal of Mountain Car problem is to reach the top of a hill when the obvious solution of accelerating does not work when starting form the bottom of the valley.\n", "\n", "https://gym.openai.com/envs/MountainCar-v0/" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "NaYswgHeLhvq" }, "outputs": [], "source": [ "import gymnasium as gym\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "env = gym.make(\"MountainCar-v0\")" ] }, { "cell_type": "markdown", "metadata": { "id": "k9w5IYGJLhvt" }, "source": [ "From the previous notebook, we can obtain the action and state space" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "U_QvDHr8Lhvv", "outputId": "4c955cc4-b948-4794-be61-c168f479cc1f" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Actions : Discrete(3)\n", "Variables: Box([-1.2 -0.07], [0.6 0.07], (2,), float32)\n", "Max. var: [0.6 0.07]\n", "Min. var: [-1.2 -0.07]\n" ] } ], "source": [ "print('Actions : ',env.action_space)\n", "print('Variables: ',env.observation_space)\n", "print('Max. var: ',env.observation_space.high)\n", "print('Min. var: ',env.observation_space.low)" ] }, { "cell_type": "markdown", "metadata": { "id": "DH_8llutLhvw" }, "source": [ "Variables correspond to position in x axis and speed. Actions correspond to forward and backward acceleration respectively.\n", "\n", "Let's see performance of random behaviour" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 508 }, "id": "FCqI1P6hLhvw", "outputId": "92e5e125-3fce-4e66-daa0-621775a0869a" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Moviepy - Building video /content/video/rl-video-episode-0.mp4.\n", "Moviepy - Writing video /content/video/rl-video-episode-0.mp4\n", "\n" ] }, { "output_type": "stream", "name": "stderr", "text": [] }, { "output_type": "stream", "name": "stdout", "text": [ "Moviepy - Done !\n", "Moviepy - video ready /content/video/rl-video-episode-0.mp4\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "" ] }, "metadata": {} } ], "source": [ "env.close()\n", "#env = gym.make(\"MountainCar-v0\")\n", "env = RecordVideo(gym.make('MountainCar-v0',render_mode='rgb_array'),video_folder='video')\n", "observation, _ = env.reset()\n", "\n", "for _ in range(300):\n", " env.render()\n", " action = env.action_space.sample() # this takes random actions\n", " observation, reward, terminated, truncated, info = env.step(action)\n", " done = truncated or terminated\n", " if done:\n", " break\n", "env.close()\n", "show_video()" ] }, { "cell_type": "markdown", "metadata": { "id": "WJcrwn39Lhvx" }, "source": [ "\n", "For this problem we will define Tile Coding. The following Class define a TileCoding. Each variable will be discretized using *numTilings* grids, each one with *tilesPerTiling x tilesPerTiling* dimension. Tiles are overlaping in the usual way:\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "OsXBvwYaLhvy" }, "outputs": [], "source": [ "class Tilecoder:\n", "\n", " def __init__(self, numTilings, tilesPerTiling):\n", " # Set max value for normalization of inputs\n", " self.maxNormal = 1\n", " self.maxVal = env.observation_space.high\n", " self.minVal = env.observation_space.low\n", " self.numTilings = numTilings\n", " self.tilesPerTiling = tilesPerTiling\n", " self.dim = len(self.maxVal)\n", " self.numTiles = (self.tilesPerTiling**self.dim) * self.numTilings\n", " self.actions = env.action_space.n\n", " self.n = self.numTiles * self.actions\n", " self.tileSize = np.divide(np.ones(self.dim)*self.maxNormal, self.tilesPerTiling-1)\n", "\n", " def getFeatures(self, variables):\n", " # Ensures range is always between 0 and self.maxValue\n", " values = np.zeros(self.dim)\n", " for i in range(len(env.observation_space.shape)+1):\n", " values[i] = self.maxNormal * ((variables[i] - self.minVal[i])/(self.maxVal[i]-self.minVal[i]))\n", " tileIndices = np.zeros(self.numTilings)\n", " matrix = np.zeros([self.numTilings,self.dim])\n", " for i in range(self.numTilings):\n", " for i2 in range(self.dim):\n", " matrix[i,i2] = int(values[i2] / self.tileSize[i2] + i / self.numTilings)\n", " for i in range(1,self.dim):\n", " matrix[:,i] *= self.tilesPerTiling**i\n", " for i in range(self.numTilings):\n", " tileIndices[i] = (i * (self.tilesPerTiling**self.dim) + sum(matrix[i,:]))\n", " return tileIndices\n", "\n", " def oneHotVector(self, features, action):\n", " oneHot = np.zeros(self.n)\n", " for i in features:\n", " index = int(i + (self.numTiles*action))\n", " oneHot[index] = 1\n", " return oneHot\n", "\n", " def getVal(self, theta, features, action):\n", " val = 0\n", " for i in features:\n", " index = int(i + (self.numTiles*action))\n", " val += theta[index]\n", " return val\n", "\n", " def getQ(self, features, theta):\n", " Q = np.zeros(self.actions)\n", " for i in range(self.actions):\n", " Q[i] = tile.getVal(theta, features, i)\n", " return Q\n" ] }, { "cell_type": "markdown", "metadata": { "id": "7RwwqDVMLhvz" }, "source": [ "## Q-learning with TileCoding\n", "\n", "Let's start defining one function to implement epsilon-greedy procedure and another one to sum long-term reward of the current episode form position *t*" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "KfDwNCIDLhv1" }, "outputs": [], "source": [ "def e_greedy_policy(Qs):\n", " return env.action_space.sample() if (np.random.random() <= epsilon) else np.argmax(Q)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "3d6nnayNLhv1" }, "source": [ "Definition of funtion to collect scores of an episode whith completely greedy policy. Just to compare scores" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "CYbG98YULhv2" }, "outputs": [], "source": [ "def rollout(niter):\n", " G = 0\n", " for i in range(niter):\n", " state, _ = env.reset()\n", " for _ in range(1000):\n", " F = tile.getFeatures(state)\n", " Q = tile.getQ(F, theta)\n", " action = np.argmax(Q)\n", " state, reward, terminated, truncated, info = env.step(action)\n", " done = truncated or terminated\n", " G += reward\n", " if done: break\n", " return G/niter\n" ] }, { "cell_type": "markdown", "metadata": { "id": "NdfIqqhwLhv3" }, "source": [ "Now, we define a TileCoder of 7x14 and apply Q-learning procedure" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Mw6qKMb3Lhv3", "outputId": "b89056b7-e0b9-41c9-da81-b87e19780251" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Average reward = -193.92\n", "Average reward = -155.38\n", "Average reward = -141.22\n", "Average reward = -128.45\n", "Average reward = -133.28\n", "Average reward = -128.48\n", "Average reward = -128.71\n", "Average reward = -127.485\n", "Average reward = -121.315\n", "Average reward = -125.105\n" ] } ], "source": [ "env = gym.make(\"MountainCar-v0\")\n", "tile = Tilecoder(7,14) # Definition of tiles (7x (14x14))\n", "theta = np.random.uniform(-0.001, 0, size=(tile.n)) # Parameters for FA (7x (14x14)) = 1.372 parameters\n", "\n", "# Parameters of learning\n", "alpha = 0.05\n", "gamma = 1\n", "numEpisodes = 2000\n", "epsilon = 0.05\n", "\n", "# Variables to collect scores\n", "rewardTracker = []\n", "rewardTracker2 = []\n", "episodeSum = 0\n", "counter = 0\n", "\n", "for episodeNum in range(1,numEpisodes+1):\n", " G = 0\n", " state,_ = env.reset()\n", " while True:\n", " F = tile.getFeatures(state) # Vector of 1.372 representing state\n", " Q = tile.getQ(F, theta) # Q-values for given state all actions\n", " action = e_greedy_policy(Q) # select action with epsilon-greedy procedure\n", " Qs = Q[action]\n", " state2, reward, terminated, truncated, info = env.step(action)\n", " done = truncated or terminated\n", " G += reward\n", " if done == True:\n", " theta += np.multiply((alpha*(reward - Qs)), tile.oneHotVector(F,action))\n", " episodeSum += G\n", " rewardTracker.append(G) # Store reward collected\n", " rewardTracker2.append(rollout(1)) # Store reward collected TESTING with epsilon = 0\n", " if episodeNum %200 == 0:\n", " print('Average reward = {}'.format(episodeSum / 200))\n", " episodeSum = 0\n", " break\n", " Q = tile.getQ(tile.getFeatures(state2), theta)\n", " theta += np.multiply((alpha*(reward - Qs+gamma*np.max(Q))), tile.oneHotVector(F,action))\n", " state = state2\n" ] }, { "cell_type": "markdown", "metadata": { "id": "2EbGU_OmLhv4" }, "source": [ "Let's see behaviour learnt" ] }, { "cell_type": "code", "source": [ "env.close()\n", "#env = gym.make(\"MountainCar-v0\")\n", "env = RecordVideo(gym.make('MountainCar-v0',render_mode='rgb_array'),video_folder='video')\n", "\n", "state, _ = env.reset()\n", "while True:\n", " env.render()\n", " F = tile.getFeatures(state) # Vector of 1.372 representing state\n", " Q = tile.getQ(F, theta) # Q-values for given state all actions\n", " action = np.argmax(Q)\n", " state, reward, terminated, truncated, info = env.step(action)\n", " done = truncated or terminated\n", " if done: break\n", "env.close()\n", "show_video()\n", "\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 562 }, "id": "gN14SiexanrI", "outputId": "d6f411d9-6298-467b-9909-bb4a4350dce7" }, "execution_count": 10, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/gymnasium/wrappers/record_video.py:94: UserWarning: \u001b[33mWARN: Overwriting existing videos at /content/video folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001b[0m\n", " logger.warn(\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Moviepy - Building video /content/video/rl-video-episode-0.mp4.\n", "Moviepy - Writing video /content/video/rl-video-episode-0.mp4\n", "\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ " " ] }, { "output_type": "stream", "name": "stdout", "text": [ "Moviepy - Done !\n", "Moviepy - video ready /content/video/rl-video-episode-0.mp4\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "\r" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "" ] }, "metadata": {} } ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 430 }, "id": "rOP3nXGeLhv5", "outputId": "a5bbf2d5-90ba-421d-bdaf-e7d320fd75ec" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "plt.plot(rewardTracker)\n", "plt.plot(rewardTracker2)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 430 }, "id": "kBnnnV3eLhv6", "outputId": "e7a3aeb7-9e04-42fc-9130-4dbefed2229c" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "def smoothen(data,window_width):\n", " cumsum_vec = np.cumsum(np.insert(data, 0, 0))\n", " return (cumsum_vec[window_width:] - cumsum_vec[:-window_width]) / window_width\n", "\n", "plt.plot(smoothen(rewardTracker2,100),label='greedy')\n", "plt.plot(smoothen(rewardTracker,100),label='e-greedy')\n", "\n", "plt.legend()\n", "plt.show()\n", "\n", "tiles_rew = rewardTracker2" ] }, { "cell_type": "markdown", "metadata": { "id": "6cEl6JJnLhv6" }, "source": [ "Just to be sure of the benefits of the approach, let's compare learning performance without FA on a single grid. To do a fair comparison, we will use approximately the same ammount of parameters, so 1 tile of 40x40, that is, 1.600 parameters" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ArYoiAOLLhv7", "outputId": "30e06dcf-b50c-4eb4-a15d-7ae20d831a0d" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -199.87\n", "Average reward = -200.0\n", "Average reward = -199.985\n" ] } ], "source": [ "env.close()\n", "env = gym.make(\"MountainCar-v0\")\n", "\n", "tile = Tilecoder(1,40)\n", "theta = np.random.uniform(-0.001, 0, size=(tile.n))\n", "alpha = 0.05\n", "gamma = 1\n", "numEpisodes = 3000\n", "rewardTracker = []\n", "rewardTracker2 = []\n", "episodeSum = 0\n", "counter = 0\n", "epsilon = 0.05\n", "\n", "for episodeNum in range(1,numEpisodes+1):\n", " G = 0\n", " state, _ = env.reset()\n", " while True:\n", " #env.render()\n", " F = tile.getFeatures(state)\n", " Q = tile.getQ(F, theta)\n", " action = e_greedy_policy(Q)\n", " #action = np.argmax(Q)\n", " Qs = Q[action]\n", " state2, reward, terminated, truncated, info = env.step(action)\n", " done = truncated or terminated\n", " G += reward\n", " if done == True:\n", " theta += np.multiply((alpha*(reward - Qs)), tile.oneHotVector(F,action))\n", " episodeSum += G\n", " rewardTracker.append(G)\n", " rewardTracker2.append(rollout(1))\n", " if episodeNum %200 == 0:\n", " print('Average reward = {}'.format(episodeSum / 200))\n", " #rewardTracker.append(episodeSum/ 100)\n", " episodeSum = 0\n", " break\n", " Q = tile.getQ(tile.getFeatures(state2), theta)\n", " theta += np.multiply((alpha*(reward - Qs+gamma*np.max(Q))), tile.oneHotVector(F,action))\n", " state = state2" ] }, { "cell_type": "markdown", "metadata": { "id": "l8saWKPWLhv7" }, "source": [ "No learning at all. Let's try to reduce the number of parameters to allow higher generalization" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1HwPJUMwLhv7", "outputId": "f75192ce-a35d-4e7e-dab8-c969efbc28c5" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Average reward = -200.0\n", "Average reward = -200.0\n", "Average reward = -198.975\n", "Average reward = -198.25\n", "Average reward = -194.4\n", "Average reward = -193.97\n", "Average reward = -187.595\n", "Average reward = -184.11\n", "Average reward = -182.775\n", "Average reward = -180.09\n", "Average reward = -183.3\n", "Average reward = -177.48\n", "Average reward = -177.155\n", "Average reward = -171.165\n", "Average reward = -164.875\n" ] } ], "source": [ "tile = Tilecoder(1,14)\n", "theta = np.random.uniform(-0.001, 0, size=(tile.n))\n", "alpha = 0.05\n", "gamma = 1\n", "numEpisodes = 3000\n", "rewardTracker = []\n", "rewardTracker2 = []\n", "episodeSum = 0\n", "counter = 0\n", "epsilon = 0.05\n", "\n", "for episodeNum in range(1,numEpisodes+1):\n", " G = 0\n", " state, _ = env.reset()\n", " while True:\n", " #env.render()\n", " F = tile.getFeatures(state)\n", " Q = tile.getQ(F, theta)\n", " action = e_greedy_policy(Q)\n", " #action = np.argmax(Q)\n", " Qs = Q[action]\n", " state2, reward, terminated, truncated, info = env.step(action)\n", " done = truncated or terminated\n", " G += reward\n", " if done == True:\n", " theta += np.multiply((alpha*(reward - Qs)), tile.oneHotVector(F,action))\n", " episodeSum += G\n", " rewardTracker.append(G)\n", " rewardTracker2.append(rollout(1))\n", " if episodeNum %200 == 0:\n", " print('Average reward = {}'.format(episodeSum / 200))\n", " #rewardTracker.append(episodeSum/ 100)\n", " episodeSum = 0\n", " break\n", " Q = tile.getQ(tile.getFeatures(state2), theta)\n", " theta += np.multiply((alpha*(reward - Qs+gamma*np.max(Q))), tile.oneHotVector(F,action))\n", " state = state2" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 430 }, "id": "hic118eKLhv8", "outputId": "79d0e35e-d368-4aa0-be02-146944b11905" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "aggre_rew = rewardTracker2\n", "plt.plot(smoothen(tiles_rew,100),label='Tiles')\n", "plt.plot(smoothen(aggre_rew,100),label='Agreg.')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "source": [ "env.close()\n", "#env = gym.make(\"MountainCar-v0\")\n", "env = RecordVideo(gym.make('MountainCar-v0',render_mode='rgb_array'),video_folder='video')\n", "\n", "state, _ = env.reset()\n", "while True:\n", " env.render()\n", " F = tile.getFeatures(state) # Vector of 1.372 representing state\n", " Q = tile.getQ(F, theta) # Q-values for given state all actions\n", " action = np.argmax(Q)\n", " state, reward, truncated, terminated, info = env.step(action)\n", " done = truncated or terminated\n", " if done: break\n", "env.close()\n", "show_video()\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 508 }, "id": "ITyx61XSd-Tz", "outputId": "b68529e5-803e-494c-97eb-ecfd32ef453e" }, "execution_count": 16, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Moviepy - Building video /content/video/rl-video-episode-0.mp4.\n", "Moviepy - Writing video /content/video/rl-video-episode-0.mp4\n", "\n" ] }, { "output_type": "stream", "name": "stderr", "text": [] }, { "output_type": "stream", "name": "stdout", "text": [ "Moviepy - Done !\n", "Moviepy - video ready /content/video/rl-video-episode-0.mp4\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "" ] }, "metadata": {} } ] }, { "cell_type": "markdown", "metadata": { "id": "LThlbjmjLhv8" }, "source": [ "## Exercises\n", "\n", "1. Try to find better parameters for agregation approach\n", "2. Play with the parameters of Tiles\n", "3. Use same approximation with Sarsa or MonteCarlo\n", "4. **Try n-steps back-up**\n", "5. Use other exploration strategies and play with functions reducing alpha and/or epsilon" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "id": "kHmod_oILhv9" }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.6.4" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 0 }