{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Eligibility traces"
]
},
{
"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": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"gym version: 0.29.1\n"
]
}
],
"source": [
"import numpy as np\n",
"rng = np.random.default_rng()\n",
"import matplotlib.pyplot as plt\n",
"import os\n",
"# os.environ[\"IMAGEIO_FFMPEG_EXE\"] = \"/opt/homebrew/bin/ffmpeg\" # if moviepy complains about not finding ffmpeg, put its path here\n",
"from IPython.display import clear_output\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",
"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": {},
"source": [
"## Q-learning in Gridworld\n",
"\n",
"### Random interaction with the environment\n",
"\n",
"The goal of this exercise is to solve the **Gridworld** problem using Q-learning. The code is adapted from \n",
"\n",
"The agent is represented by the blue circle: the **state** $s$ of the agent is its position in the 5x5 grid, i.e. a number between 0 and 24.\n",
"\n",
"The agent can move either to the left, right, top or bottom. When the agent tries to move outside of the environment, it stays at its current position. There are four **actions** $a$ available, which are deterministic. \n",
"\n",
"Its goal is to reach the green circle, while avoiding the red ones. Actions leading to the green circle receive a reward $r$ of +100, actions leading to a red square receive a reward of -100. The episode ends in those states. All other actions have a reward of -1. An episode stops after 100 steps if a goal has not been reached."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"class GridWorldEnv(gym.Env):\n",
" metadata = {\"render_modes\": [\"human\", \"rgb_array\", \"rgb_array_list\"], \"render_fps\": 4}\n",
"\n",
" def __init__(self, render_mode=None, size=5, rewards=[100, -100, -1]):\n",
" self.size = size # The size of the square grid\n",
" self.window_size = 512 # The size of the PyGame window\n",
" self.rewards = rewards\n",
" self._step = 0\n",
"\n",
" # The state is the flattened (x, y) coordinate of the agent\n",
" self.observation_space = gym.spaces.Discrete(size**2)\n",
"\n",
" # Goal location\n",
" self._target_location = np.array([3, 2], dtype=int)\n",
" self._distractor1_location = np.array([3, 1], dtype=int)\n",
" self._distractor2_location = np.array([2, 2], dtype=int)\n",
"\n",
" # We have 4 actions, corresponding to \"right\", \"up\", \"left\", \"down\"\n",
" self.action_space = gym.spaces.Discrete(4)\n",
"\n",
" self._action_to_direction = {\n",
" 0: np.array([1, 0]), # right\n",
" 1: np.array([0, 1]), # down\n",
" 2: np.array([-1, 0]), # left\n",
" 3: np.array([0, -1]), # up\n",
" }\n",
"\n",
" assert render_mode is None or render_mode in self.metadata[\"render_modes\"]\n",
" self.render_mode = render_mode\n",
"\n",
" if self.render_mode == \"rgb_array_list\":\n",
" self._frames = []\n",
" self.window = None\n",
" self.clock = None\n",
" self.font = pygame.font.SysFont(None, 16)\n",
" self.Q = np.zeros((self.observation_space.n, self.action_space.n))\n",
"\n",
"\n",
" def _state2coordinates(self, state):\n",
" \"Returns coordinates of a state.\"\n",
" return (state % self.size, int(state/self.size))\n",
"\n",
" def _coordinate2state(self, coord):\n",
" \"Returns the state with the coordinates.\"\n",
" return coord[1] * self.size + coord[0]\n",
"\n",
" def reset(self, seed=None, options=None):\n",
"\n",
" self._step = 0\n",
"\n",
" # Initial location\n",
" self._agent_location = np.array([0, 0], dtype=int)\n",
"\n",
" if self.render_mode == \"human\":\n",
" self._render_frame()\n",
" \n",
" if self.render_mode == \"rgb_array_list\":\n",
" self._frames = []\n",
" self._render_frame()\n",
"\n",
" return self._coordinate2state(self._agent_location), {}\n",
"\n",
"\n",
" def step(self, action):\n",
"\n",
" # Map the action (element of {0,1,2,3}) to the direction we walk in\n",
" direction = self._action_to_direction[action]\n",
" \n",
" # We use `np.clip` to make sure we don't leave the grid\n",
" self._agent_location = np.clip(\n",
" self._agent_location + direction, 0, self.size - 1\n",
" )\n",
" \n",
" # An episode is done if the agent has reached the target or the distractors\n",
" if np.array_equal(self._agent_location, self._target_location):\n",
" terminal = True\n",
" reward = self.rewards[0]\n",
" elif np.array_equal(self._agent_location, self._distractor1_location) \\\n",
" or np.array_equal(self._agent_location, self._distractor2_location):\n",
" terminal = True\n",
" reward = self.rewards[1]\n",
" else:\n",
" terminal = False\n",
" reward = self.rewards[2]\n",
"\n",
" if self.render_mode == \"human\" or self.render_mode == \"rgb_array_list\":\n",
" self._render_frame()\n",
"\n",
" self._step += 1\n",
" if self._step == 100:\n",
" truncated = True\n",
" else:\n",
" truncated = False\n",
"\n",
" return self._coordinate2state(self._agent_location), reward, terminal, truncated, {}\n",
"\n",
" def render(self):\n",
" if self.render_mode == \"rgb_array\":\n",
" return self._render_frame()\n",
" elif self.render_mode == \"rgb_array_list\":\n",
" f = self._frames.copy()\n",
" self._frames = []\n",
" return f\n",
"\n",
" def _render_frame(self):\n",
"\n",
" if self.window is None and self.render_mode == \"human\":\n",
" pygame.init()\n",
" pygame.display.init()\n",
" self.window = pygame.display.set_mode(\n",
" (self.window_size, self.window_size)\n",
" )\n",
" if self.clock is None and self.render_mode == \"human\":\n",
" self.clock = pygame.time.Clock()\n",
"\n",
" canvas = pygame.Surface((self.window_size, self.window_size))\n",
" canvas.fill((255, 255, 255))\n",
" pix_square_size = (\n",
" self.window_size / self.size\n",
" ) # The size of a single grid square in pixels\n",
"\n",
" # First we draw the target and the distractors\n",
" pygame.draw.rect(\n",
" canvas,\n",
" (0, 255, 0),\n",
" pygame.Rect(\n",
" pix_square_size * self._target_location,\n",
" (pix_square_size, pix_square_size),\n",
" ),\n",
" )\n",
" pygame.draw.rect(\n",
" canvas,\n",
" (255, 0, 0),\n",
" pygame.Rect(\n",
" pix_square_size * self._distractor1_location,\n",
" (pix_square_size, pix_square_size),\n",
" ),\n",
" )\n",
" pygame.draw.rect(\n",
" canvas,\n",
" (255, 0, 0),\n",
" pygame.Rect(\n",
" pix_square_size * self._distractor2_location,\n",
" (pix_square_size, pix_square_size),\n",
" ),\n",
" )\n",
"\n",
" # Now we draw the agent\n",
" pygame.draw.circle(\n",
" canvas,\n",
" (0, 0, 255),\n",
" (self._agent_location + 0.5) * pix_square_size,\n",
" pix_square_size / 3,\n",
" )\n",
"\n",
" # Add some gridlines\n",
" for x in range(self.size + 1):\n",
" pygame.draw.line(\n",
" canvas,\n",
" 0,\n",
" (0, pix_square_size * x),\n",
" (self.window_size, pix_square_size * x),\n",
" width=3,\n",
" )\n",
" pygame.draw.line(\n",
" canvas,\n",
" 0,\n",
" (pix_square_size * x, 0),\n",
" (pix_square_size * x, self.window_size),\n",
" width=3,\n",
" )\n",
"\n",
" # Print Q-values\n",
" for x in range(self.size):\n",
" for y in range(self.size):\n",
" s = self._coordinate2state((x, y))\n",
" \n",
" # Up\n",
" val = f\"{self.Q[s, 3]:+.2f}\"\n",
" text = self.font.render(val, True, (0, 0, 0))\n",
" canvas.blit(text, \n",
" ((x + 0.5) * pix_square_size - 6, \n",
" (y) * pix_square_size + 6)\n",
" )\n",
" # Down\n",
" val = f\"{self.Q[s, 1]:+.2f}\"\n",
" text = self.font.render(val, True, (0, 0, 0))\n",
" canvas.blit(text, \n",
" ((x + 0.5) * pix_square_size - 6, \n",
" (y+1) * pix_square_size - 12)\n",
" )\n",
" # Left\n",
" val = f\"{self.Q[s, 2]:+.2f}\"\n",
" text = self.font.render(val, True, (0, 0, 0))\n",
" canvas.blit(text, \n",
" ((x) * pix_square_size + 6, \n",
" (y+ 0.5) * pix_square_size - 6)\n",
" )\n",
" # Right\n",
" val = f\"{self.Q[s, 0]:+.2f}\"\n",
" text = self.font.render(val, True, (0, 0, 0))\n",
" canvas.blit(text, \n",
" ((x + 1) * pix_square_size - 32, \n",
" (y+ 0.5) * pix_square_size - 6)\n",
" )\n",
"\n",
"\n",
" if self.render_mode == \"human\":\n",
" # The following line copies our drawings from `canvas` to the visible window\n",
" self.window.blit(canvas, canvas.get_rect())\n",
" pygame.event.pump()\n",
" pygame.display.update()\n",
"\n",
" # We need to ensure that human-rendering occurs at the predefined framerate.\n",
" # The following line will automatically add a delay to keep the framerate stable.\n",
" self.clock.tick(self.metadata[\"render_fps\"])\n",
"\n",
" elif self.render_mode == \"rgb_array\":\n",
" return np.transpose(\n",
" np.array(pygame.surfarray.pixels3d(canvas)), axes=(1, 0, 2)\n",
" )\n",
" elif self.render_mode == \"rgb_array_list\":\n",
" array = np.transpose(\n",
" np.array(pygame.surfarray.pixels3d(canvas)), axes=(1, 0, 2)\n",
" )\n",
" self._frames.append(array)\n",
"\n",
" def close(self):\n",
" if self.window is not None:\n",
" pygame.display.quit()\n",
" pygame.quit()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"class RandomAgent:\n",
" \n",
" def __init__(self, env):\n",
" self.env = env\n",
" self.Q = np.zeros((self.env.observation_space.n, self.env.action_space.n))\n",
" \n",
" def act(self, state):\n",
" \"Selects an action randomly\"\n",
" return self.env.action_space.sample()\n",
" \n",
" def train(self, nb_episodes, recorder=None):\n",
" \"Runs the agent on the environment for nb_episodes.\"\n",
" # Returns\n",
" returns = []\n",
" steps = []\n",
"\n",
" # Fixed number of episodes\n",
" for episode in range(nb_episodes):\n",
"\n",
" # Reset\n",
" state, info = self.env.reset()\n",
" done = False\n",
" nb_steps = 0\n",
"\n",
" # Store rewards\n",
" return_episode = 0.0\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",
" # Append reward\n",
" return_episode += reward\n",
"\n",
" # Go in the next state\n",
" state = next_state\n",
"\n",
" # Increment time\n",
" nb_steps += 1\n",
"\n",
" # Terminal state\n",
" done = terminal or truncated\n",
" \n",
" # Pass the Q table to the GUI\n",
" self.env.Q = self.Q \n",
"\n",
" # Store info\n",
" returns.append(return_episode)\n",
" steps.append(nb_steps)\n",
" \n",
" return returns, steps"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Create the environment\n",
"env = GridWorldEnv(render_mode='human')\n",
"\n",
"# Create the agent\n",
"agent = RandomAgent(env)\n",
"\n",
"# Perform random episodes\n",
"returns, steps = agent.train(2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Q:** Adapt your Q-learning agent from last exercise to the problem. The main difference is the call to `self.env.Q = self.Q` so that the GUI displays the Q-values, the rest is similar. Train it for 100 episodes with the right hyperparameters and without rendering."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"class QLearningAgent:\n",
" \"\"\"\n",
" Q-learning agent.\n",
" \"\"\"\n",
" \n",
" def __init__(self, env, gamma, exploration, decay, alpha):\n",
" \"\"\"\n",
" :param env: gym-like environment\n",
" :param gamma: discount factor\n",
" :param exploration: exploration parameter\n",
" :param decay: exploration decay parameter\n",
" :param alpha: learning rate\n",
" \"\"\"\n",
" self.env = env\n",
" self.gamma = gamma\n",
" self.exploration = exploration\n",
" self.decay = decay\n",
" self.alpha = alpha\n",
" \n",
" # Q_table\n",
" self.Q = np.zeros([self.env.observation_space.n, self.env.action_space.n])\n",
" \n",
" def act(self, state):\n",
" \"Returns an action using epsilon-greedy action selection.\"\n",
" \n",
" action = rng.choice(np.where(self.Q[state, :] == self.Q[state, :].max())[0])\n",
" \n",
" if rng.random() < self.exploration:\n",
" action = self.env.action_space.sample() \n",
" \n",
" return action\n",
" \n",
" def update(self, state, action, reward, next_state, done):\n",
" \"Updates the agent using a single transition.\"\n",
" \n",
" # Bellman target\n",
" target = reward\n",
" \n",
" if not done:\n",
" target += self.gamma * self.Q[next_state, :].max()\n",
" \n",
" # Update the Q-value\n",
" self.Q[state, action] += self.alpha * (target - self.Q[state, action])\n",
" \n",
" # Decay exploration parameter\n",
" self.exploration = self.exploration * (1 - self.decay)\n",
" \n",
" \n",
" def train(self, nb_episodes, recorder=None):\n",
" \"Runs the agent on the environment for nb_episodes.\"\n",
"\n",
" # Returns\n",
" returns = []\n",
" steps = []\n",
"\n",
" # Fixed number of episodes\n",
" for episode in range(nb_episodes):\n",
"\n",
" # Reset\n",
" state, info = self.env.reset()\n",
" done = False\n",
" nb_steps = 0\n",
"\n",
" # Store rewards\n",
" return_episode = 0.0\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",
" # Terminal state\n",
" done = terminal or truncated\n",
" \n",
" # Append reward\n",
" return_episode += reward\n",
"\n",
" # Learn from the transition\n",
" self.update(state, action, reward, next_state, done)\n",
"\n",
" # Go in the next state\n",
" state = next_state\n",
"\n",
" # Increment time\n",
" nb_steps += 1\n",
" \n",
" # Pass the Q table to the GUI\n",
" self.env.Q = self.Q\n",
"\n",
" # Store info\n",
" returns.append(return_episode)\n",
" steps.append(nb_steps)\n",
"\n",
" if recorder is not None:\n",
" recorder.record(self.env.render())\n",
" \n",
" return returns, steps\n",
" \n",
" def test(self, recorder=None):\n",
" \"Performs a test episode without exploration.\"\n",
" previous_epsilon = self.epsilon\n",
" self.epsilon = 0.0\n",
" \n",
" # Reset\n",
" state, info = self.env.reset()\n",
" done = False\n",
" nb_steps = 0\n",
" return_episode= 0\n",
"\n",
" # Sample the episode\n",
" while not done:\n",
" action = self.act(state)\n",
" next_state, reward, done, info = self.env.step(action)\n",
" return_episode += reward\n",
" state = next_state\n",
" nb_steps += 1\n",
" \n",
" self.epsilon = previous_epsilon\n",
"\n",
" if recorder is not None:\n",
" recorder.record(self.env.render())\n",
" \n",
" return return_episode, nb_steps"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"