From 53c0384cf9fce9f1c3ec29591b60891980265891 Mon Sep 17 00:00:00 2001 From: Arthur DANJOU Date: Tue, 3 Feb 2026 11:42:21 +0100 Subject: [PATCH] Implement feature X to enhance user experience and optimize performance --- ...tion approximation with Mountain Car.ipynb | 1109 +++++++++++++++++ 1 file changed, 1109 insertions(+) create mode 100644 M2/Reinforcement Learning/Lab 7 - Function approximation with Mountain Car.ipynb diff --git a/M2/Reinforcement Learning/Lab 7 - Function approximation with Mountain Car.ipynb b/M2/Reinforcement Learning/Lab 7 - Function approximation with Mountain Car.ipynb new file mode 100644 index 0000000..ee49d5f --- /dev/null +++ b/M2/Reinforcement Learning/Lab 7 - Function approximation with Mountain Car.ipynb @@ -0,0 +1,1109 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "340f3946", + "metadata": {}, + "source": [ + "# Lab 7: Function approximation + Tile Coding + Semi-gradient SARSA in Mountain Car (Sutton & Barto Example 10.1)\n", + "\n", + "## Learning objectives\n", + "In this lab, we will\n", + "- implement **tile coding** features for continuous states\n", + "- implement **semi-gradient SARSA** with a **linear function approximator**\n", + "- train on the **Mountain Car** task and analyze learning curves\n", + "\n", + "**Reminder:** In Mountain Car, the agent must often go *left first* to build momentum and then reach the goal on the right.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d3a740c6", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "rng = np.random.default_rng(42)" + ] + }, + { + "cell_type": "markdown", + "id": "e0261140-4c94-4f8c-b075-c02cb9d70ee9", + "metadata": {}, + "source": [ + "## 1. Environment: Mountain Car\n", + "\n", + "The Mountain Car problem is a classic benchmark in Reinforcement Learning designed to highlight the challenges of\n", + "continuous state spaces. \n", + "\n", + "**State Space.**\n", + "At each time step, the agent observes a continuous state $s=(x,v)$, where \n", + "\n", + "- position $x \\in [-1.2, 0.5]$ represents the horizontal location of the car along a valley between two hills.\n", + "\n", + "- velocity $v \\in [-0.07, 0.07]$ represents the car’s speed (positive = moving right, negative = moving left).\n", + "\n", + "The state space is continuous and two-dimensional, which means the tabular methods are not directly applicable.\n", + "\n", + "**Action Space.** The agent can choose one of three discrete actions $a\\in\\{-1,0,1\\}$\n", + "\n", + "-1: push the car to the left\n", + "\n", + "0: no push\n", + "\n", + "+1: push the car to the right\n", + "\n", + "Remark. The car’s engine is not powerful enough to drive directly up the right hill to the goal. As a result, simply pushing right all the time fails. The agent must first move left, build momentum, and then accelerate right.\n", + "\n", + "**Reward.** \n", + "- $r_t=-1$ each step until the car reaches the goal ($x\\ge 0.5$). Then the episode terminates.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "01202f09-ed6c-4f92-abaa-30dbc8def9d3", + "metadata": {}, + "outputs": [], + "source": [ + "class MountainCar:\n", + " \"\"\"Minimal Mountain Car environment with continuous state space (position, velocity) discrete action space (push left / no push / push right).\n", + "\n", + " This implementation follows the classic Mountain Car dynamics\n", + " used in Sutton & Barto.\n", + " \"\"\"\n", + "\n", + " def __init__(self, seed: int = 0) -> None:\n", + " \"\"\"Initialize the Mountain Car environment. Optionally set a random seed for reproducibility.\"\"\"\n", + " # Create a dedicated random number generator for this environment.\n", + " # Using a local RNG for reproducibility\n", + " # and avoids interference with randomness used elsewhere.\n", + " self.rng = np.random.default_rng(seed)\n", + "\n", + " # Initialize the environment to a valid starting state.\n", + " # This sets self.x and self.v and returns the initial state.\n", + " self.reset()\n", + "\n", + " def reset(self) -> np.ndarray:\n", + " \"\"\"Reset the environment at the beginning of a new episode.\"\"\"\n", + " # Sample the initial position uniformly in a small interval\n", + " # around the bottom of the valley (approximately x = -0.5).\n", + " # Starting here ensures the task is non-trivial and requires momentum.\n", + " self.x = float(self.rng.uniform(-0.6, -0.4))\n", + "\n", + " # Initial velocity is set to zero (no initial momentum).\n", + " self.v = 0.0\n", + "\n", + " # Return the initial state as a NumPy array: [position, velocity]\n", + " # Using float64 ensures numerical consistency and stability.\n", + " return np.array([self.x, self.v], dtype=np.float64)\n", + "\n", + " @staticmethod\n", + " def step_dynamics(x: np.ndarray, v: float, a: int) -> tuple[float, float]:\n", + " \"\"\"Compute the next state given current position x, velocity v, and action a.\"\"\"\n", + " # This function is static because it does not depend\n", + " # on any internal state of the environment object.\n", + "\n", + " # Update the velocity using the Mountain Car physics:\n", + " # - 0.001 * a : acceleration from the engine\n", + " # - -0.0025*cos(3x): gravity pulling the car downhill\n", + " #\n", + " # Important: the engine alone is not strong enough\n", + " # to push the car directly to the goal.\n", + " v = v + 0.001 * a - 0.0025 * np.cos(3 * x)\n", + "\n", + " # Clip the velocity to its allowed range.\n", + " # This prevents unrealistic speeds and numerical instability.\n", + " v = float(np.clip(v, -0.07, 0.07))\n", + "\n", + " # Update the position using the new velocity.\n", + " x = x + v\n", + "\n", + " # Clip the position to the allowed interval.\n", + " # The right boundary (0.5) corresponds to the goal.\n", + " x = np.clip(x, -1.2, 0.5)\n", + "\n", + " # If the car hits the left boundary,\n", + " # its velocity is reset to zero.\n", + " # This models an inelastic collision with the wall\n", + " # and matches the standard Mountain Car convention.\n", + " if x <= -1.2: # noqa: PLR2004\n", + " v = 0.0\n", + "\n", + " # Return the updated continuous state.\n", + " return x, v\n", + "\n", + " def step(self, a: int) -> tuple[np.ndarray, float, bool]:\n", + " \"\"\"Take an action a and return the next state, reward, and done flag.\"\"\"\n", + " # Update the internal state (x, v) using the dynamics function.\n", + " # Action is explicitly cast to int to avoid type issues\n", + " # (e.g., when actions come from NumPy arrays or policies).\n", + " self.x, self.v = MountainCar.step_dynamics(self.x, self.v, int(a)) # ty:ignore[invalid-argument-type]\n", + "\n", + " # Construct the next state as a NumPy array\n", + " # to be returned to the agent.\n", + " s = np.array([self.x, self.v], dtype=np.float64)\n", + "\n", + " # Check whether the episode has terminated.\n", + " # The episode ends once the car reaches the goal position.\n", + " done = bool(self.x >= 0.5) # noqa: PLR2004\n", + "\n", + " # Reward structure:\n", + " # - reward = -1 at every time step\n", + " # - reward = 0 when the goal is reached (terminal state)\n", + " #\n", + " # This encourages the agent to reach the goal\n", + " # in as few steps as possible.\n", + " r = 0.0 if done else -1.0\n", + "\n", + " # Return the standard RL tuple: (next_state, reward, done)\n", + " return s, r, done\n" + ] + }, + { + "cell_type": "markdown", + "id": "72bc21fa", + "metadata": {}, + "source": [ + "Before implementing any learning algorithm, we first establish a baseline by running the Mountain Car environment with a random policy." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "273fce79", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random-policy episode length: 7452 steps\n" + ] + } + ], + "source": [ + "# Create an instance of the Mountain Car environment.\n", + "# The seed fixes the randomness so that results are reproducible\n", + "# (same initial states and same random action sequences).\n", + "env = MountainCar(seed=0)\n", + "\n", + "# Define the discrete action space explicitly:\n", + "# -1 : push left\n", + "# 0 : no push\n", + "# +1 : push right\n", + "# Storing actions in an array makes random sampling and later policies easier.\n", + "ACTIONS = np.array([-1, 0, +1], dtype=int)\n", + "\n", + "# Reset the environment to start a new episode.\n", + "# This initializes the position and velocity and returns the initial state.\n", + "s = env.reset()\n", + "\n", + "# Counter to track how many time steps are taken in this episode.\n", + "# Episode length is the main performance metric in Mountain Car.\n", + "steps = 0\n", + "\n", + "# Run the episode until termination.\n", + "# We use an infinite loop and manually break when the episode ends.\n", + "while True:\n", + " # Select an action uniformly at random from the action set.\n", + " # This corresponds to a random (uninformed) policy.\n", + " a = int(rng.choice(ACTIONS))\n", + "\n", + " # Apply the chosen action to the environment.\n", + " # This returns:\n", + " # - s : next state (position, velocity)\n", + " # - r : reward obtained after the action\n", + " # - done : whether the episode has terminated\n", + " s, r, done = env.step(a)\n", + "\n", + " # Increment the step counter.\n", + " steps += 1\n", + "\n", + " # Stop the episode if:\n", + " # - the goal is reached (done == True), or\n", + " # - a safety cap on episode length is exceeded\n", + " # (prevents infinite loops under bad policies).\n", + " if done or steps > 10000: # noqa: PLR2004\n", + " break\n", + "\n", + "# Print the episode length obtained under the random policy.\n", + "# Since reward is -1 at each step, shorter episodes correspond\n", + "# to higher total return.\n", + "print(f\"Random-policy episode length: {steps} steps\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "238a441e-2135-4845-87aa-2eb535e7f777", + "metadata": {}, + "source": [ + "## 2. Tile Coding for Continuous State Spaces\n", + "\n", + "In the Mountain Car problem, the state $s=(x,v)$ (position and velocity) is continuous.\n", + "This means that classic tabular methods (one value per state or per state–action pair) are not feasible: there are infinitely many possible states. To apply value-based control methods such as SARSA or Q-learning, we therefore need a function approximation technique that handles continuous inputs and is simple and interpretable,\n", + "\n", + "In this lab, we use **tile coding**.\n", + "\n", + "**Principle of tile coding**\n", + "\n", + "Tile coding approximates a continuous state space by combining multiple coarse discretizations, called tilings.\n", + "\n", + "Each tiling is a regular grid over the $(x,v)$ space.\n", + "\n", + "The grids are slightly shifted relative to each other.\n", + "\n", + "For a given state $s$: exactly one tile is active in each tiling, all other tiles are inactive.\n", + "\n", + "As a result, the feature vector $\\varphi(s)$ is sparse, nearby states activate overlapping but not identical sets of tiles.\n", + "\n", + "**Why multiple tilings?**\n", + "\n", + "Using a single grid leads to hard discretization boundaries: two very close states may fall into different bins and share no information.\n", + "\n", + "By using multiple offset tilings: nearby states share some active tiles, distant states share few or none, the representation is both smooth and expressive.\n", + "\n", + "This gives a good tradeoff: with coarse tiles $\\rightarrow$ generalization and multiple tilings $\\rightarrow$ precision.\n", + "\n", + "**Action-dependent features**\n", + "\n", + "In control problems, we need to approximate the action-value function $q(s,a)$. To do this, tile coding is extended to state–action pairs, that is, **each action has its own set of tilings and features for different actions do not overlap.**\n", + "\n", + "**Sparse linear approximation**\n", + "\n", + "In this lab, the approximate action-value function takes the form $\\hat{q}(s,a)=\\sum_{i\\in\\mathcal{I}(s,a)}w_i$, where $\\mathcal{I}(s,a)$ is the set of active tile indices. \n", + "\n", + "In fact, by using this expression, computation is fast since only a few weights are used." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b7bca537-9d1e-45eb-a20b-13a42d07ea85", + "metadata": {}, + "outputs": [], + "source": [ + "class TileCoder:\n", + " \"\"\"Tile coding feature representation for Mountain Car with continuous states.\n", + "\n", + " The idea:\n", + " - The state s = (x, v) is continuous and cannot be handled with a tabular method.\n", + " - We discretize the state space using multiple overlapping grids (tilings).\n", + " - Each tiling maps a continuous state to exactly ONE active tile.\n", + " - Using multiple shifted tilings allows generalization while preserving resolution.\n", + "\n", + " For a given (state, action) pair:\n", + " - Exactly one tile is active per tiling.\n", + " - Therefore, the feature vector phi(s,a) has exactly `n_tilings` active components (equal to 1).\n", + "\n", + " Implementation detail:\n", + " - We never explicitly build the full phi(s,a) vector of size d.\n", + " - Instead, we return the indices of the active features.\n", + " - This allows efficient computation of q(s,a) = sum(w[idx]) and efficient weight updates.\n", + " \"\"\"\n", + "\n", + " def __init__( # noqa: PLR0913\n", + " self,\n", + " x_range: tuple[float, float] = (-1.2, 0.5),\n", + " v_range: tuple[float, float] = (-0.07, 0.07),\n", + " n_tilings: int = 8,\n", + " n_x: int = 8,\n", + " n_v: int = 8,\n", + " n_actions: int = 3,\n", + " ) -> None:\n", + " \"\"\"Initialize the TileCoder with specified parameters.\"\"\"\n", + " # Store the minimum and maximum values for position.\n", + " # These define the bounds of the Mountain Car state space.\n", + " self.x_min, self.x_max = x_range\n", + "\n", + " # Store the minimum and maximum values for velocity.\n", + " self.v_min, self.v_max = v_range\n", + "\n", + " # Number of overlapping tilings (grids).\n", + " # More tilings -> better generalization but higher computational cost.\n", + " self.n_tilings = int(n_tilings)\n", + "\n", + " # Number of tiles along the position dimension per tiling.\n", + " self.n_x = int(n_x)\n", + "\n", + " # Number of tiles along the velocity dimension per tiling.\n", + " self.n_v = int(n_v)\n", + "\n", + " # Number of discrete actions.\n", + " # For Mountain Car: {-1, 0, +1} → 3 actions.\n", + " self.n_actions = int(n_actions)\n", + "\n", + " # Number of tiles in ONE tiling (2D grid).\n", + " # Each tiling is an n_x by n_v grid.\n", + " self.tiles_per_tiling = self.n_x * self.n_v\n", + "\n", + " # Total number of features:\n", + " # action x tiling x tile\n", + " #\n", + " # Each action has its own independent set of tilings.\n", + " # This corresponds to using separate value functions for each action.\n", + " self.d = self.n_actions * self.n_tilings * self.tiles_per_tiling\n", + "\n", + " # Compute tile width along the position dimension.\n", + " # This is the spacing between neighboring tile centers.\n", + " #\n", + " # Using (n_x - 1) ensures that x_min and x_max lie exactly\n", + " # on the grid boundaries.\n", + " self.x_w = (self.x_max - self.x_min) / (self.n_x - 1)\n", + "\n", + " # Compute tile width along the velocity dimension.\n", + " self.v_w = (self.v_max - self.v_min) / (self.n_v - 1)\n", + "\n", + " # Offsets for each tiling in the position dimension.\n", + " # Each tiling is shifted slightly relative to the others.\n", + " #\n", + " # This creates overlapping grids, which is the key idea\n", + " # behind tile coding generalization.\n", + " self.x_offsets = np.linspace(0.0, self.x_w, self.n_tilings, endpoint=False)\n", + "\n", + " # Offsets for each tiling in the velocity dimension.\n", + " # We use the same number of offsets as tilings.\n", + " self.v_offsets = np.linspace(0.0, self.v_w, self.n_tilings, endpoint=False)\n", + "\n", + " def _action_id(self, a: int) -> int:\n", + " \"\"\"Convert environment action values {-1, 0, +1} into internal action indices {0, 1, 2}.\n", + "\n", + " This mapping is necessary because array indexing\n", + " must start from 0.\n", + " \"\"\"\n", + " # Push left → index 0\n", + " if a == -1:\n", + " return 0\n", + "\n", + " # No push → index 1\n", + " if a == 0:\n", + " return 1\n", + "\n", + " # Push right → index 2\n", + " if a == +1:\n", + " return 2\n", + "\n", + " # Any other value is invalid.\n", + " error = \"Action must be one of {-1, 0, +1}.\"\n", + " raise ValueError(error)\n", + "\n", + " def encode(self, s: np.ndarray, a: int) -> np.ndarray:\n", + " \"\"\"Compute the active tile indices for a given (state, action) pair.\n", + "\n", + " Args:\n", + " s : np.array([x, v])\n", + " Continuous Mountain Car state.\n", + " a : int\n", + " Action in {-1, 0, +1}.\n", + "\n", + " Returns:\n", + " idx : np.array of shape (n_tilings,)\n", + " Indices of the active features.\n", + "\n", + " Indexing scheme:\n", + " global_index =\n", + " ((action_id * n_tilings + tiling_id) * tiles_per_tiling)\n", + " + tile_id\n", + "\n", + " where:\n", + " tile_id = ix * n_v + iv\n", + "\n", + " \"\"\"\n", + " # Extract continuous position and velocity from the state.\n", + " # Convert explicitly to float for numerical safety.\n", + " x, v = float(s[0]), float(s[1])\n", + "\n", + " # Convert the environment action into an internal action index.\n", + " action_id = self._action_id(int(a))\n", + "\n", + " # Allocate an array to store the active feature index\n", + " # for each tiling.\n", + " idx = np.empty(self.n_tilings, dtype=np.int64)\n", + "\n", + " # Loop over all tilings.\n", + " # Each tiling produces exactly one active tile.\n", + " for k in range(self.n_tilings):\n", + " # 1) Apply the tiling-specific offset.\n", + " # This shifts the grid so that different tilings\n", + " # partition the space differently.\n", + " xk = x + self.x_offsets[k]\n", + " vk = v + self.v_offsets[k]\n", + "\n", + " # 2) Convert continuous coordinates to discrete grid indices.\n", + " #\n", + " # Subtract the minimum value, divide by tile width,\n", + " # and round down to get the tile index.\n", + " ix = int(np.floor((xk - self.x_min) / self.x_w))\n", + " iv = int(np.floor((vk - self.v_min) / self.v_w))\n", + "\n", + " # 3) Clamp indices to valid ranges.\n", + " # This handles boundary cases where rounding\n", + " # might push indices outside the grid.\n", + " ix = int(np.clip(ix, 0, self.n_x - 1))\n", + " iv = int(np.clip(iv, 0, self.n_v - 1))\n", + "\n", + " # 4) Flatten the 2D tile index (ix, iv)\n", + " # into a single tile_id.\n", + " #\n", + " # This is row-major ordering.\n", + " tile_id = ix * self.n_v + iv\n", + "\n", + " # 5) Compute the global feature index.\n", + " #\n", + " # Layout: [ action ] [ tiling ] [ tile ] # noqa: ERA001\n", + " #\n", + " # This ensures that:\n", + " # - different actions do not share features,\n", + " # - each tiling has its own independent grid.\n", + " idx[k] = (action_id * self.n_tilings + k) * self.tiles_per_tiling + tile_id\n", + "\n", + " # Return the list of active feature indices.\n", + " # The corresponding feature values are implicitly 1.\n", + " return idx\n" + ] + }, + { + "cell_type": "markdown", + "id": "fd64b490-8853-4b3e-81f7-f6a7dfbc132a", + "metadata": {}, + "source": [ + "**Exercise 1.** In this exercise, we study how tile coding maps continuous states to sparse feature representations and how it provides generalization across nearby states. \n", + "\n", + "Question 1 - Run the code below and note the value of the feature dimension $d$. Write down the formula used to compute d in terms of number of actions, number of tilings and number of tiles per tiling." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4e772464-e7ed-42b0-96f8-6857eab5cbcb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature dimension d = 768\n" + ] + } + ], + "source": [ + "tc = TileCoder(n_tilings=4, n_x=8, n_v=8)\n", + "print(\"Feature dimension d =\", tc.d)" + ] + }, + { + "cell_type": "markdown", + "id": "a5b738b4-c3b1-49ca-a5e5-e1846128f753", + "metadata": {}, + "source": [ + "Question 2 - We now test how tile coding behaves for two nearby states. Explain why we fix the action to -1 in this experiment. What does the variable `shared` measure? " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a518b6b5-cda4-4493-8bce-2548b4096620", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shared active tiles between nearby states: 4/4\n" + ] + } + ], + "source": [ + "s1 = np.array([-0.50, 0.00])\n", + "s2 = np.array([-0.49, 0.00]) # change the value of s2 and test\n", + "idx1 = set(tc.encode(s1, -1).tolist())\n", + "idx2 = set(tc.encode(s2, -1).tolist())\n", + "shared = len(idx1.intersection(idx2))\n", + "print(f\"Shared active tiles between nearby states: {shared}/{tc.n_tilings}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d770e756", + "metadata": {}, + "source": [ + "## 3. Semi-gradient SARSA with linear function approximation\n", + "\n", + "\n", + "We now combine **tile coding** with a **control algorithm** to learn how to solve the Mountain Car task.\n", + "\n", + "Since the state space $(x,v)$ is continuous, we cannot use a tabular representation for the action-value function $q(s,a)$. Instead, we use **linear function approximation** together with the tile-coded features introduced earlier.\n", + "\n", + "**Objective**\n", + "\n", + "Our goal is to approximate the action-value function:\n", + "$$\n", + "q_\\pi(s,a) = \\mathbb{E}_\\pi[G_t \\mid S_t = s, A_t = a]\n", + "$$\n", + "using a parameterized model:\n", + "$$\n", + "\\hat q(s,a; \\mathbf{w}) = \\mathbf{w}^\\top \\phi(s,a),\n", + "$$\n", + "where:\n", + "- $\\phi(s,a)$ is a **sparse binary feature vector** produced by tile coding (see Section 2.),\n", + "- $\\mathbf{w}$ is a vector of learnable weights.\n", + "\n", + "Because tile coding activates **exactly one tile per tiling**, $\\phi(s,a)$ has exactly `n_tilings` non-zero entries. This means\n", + "$$\n", + "\\hat q(s,a) = \\sum_{i \\in \\mathcal{I}(s,a)} w_i,\n", + "$$\n", + "where $\\mathcal{I}(s,a)$ is the set of active feature indices.\n", + "\n", + "**Algorithm: Semi-gradient SARSA**\n", + "\n", + "We use **SARSA**, an on-policy temporal-difference control algorithm.\n", + "\n", + "At each time step, given a transition\n", + "$$\n", + "(s, a, r, s', a'),\n", + "$$\n", + "the **TD error** is computed as:\n", + "$$\n", + "\\delta =\n", + "\\begin{cases}\n", + "r - \\hat q(s,a), & \\text{if } s' \\text{ is terminal}, \\\\\n", + "r + \\gamma \\hat q(s',a') - \\hat q(s,a), & \\text{otherwise}.\n", + "\\end{cases}\n", + "$$\n", + "\n", + "The **semi-gradient update** for linear function approximation is:\n", + "$$\n", + "w_i \\leftarrow w_i + \\alpha \\, \\delta\n", + "\\quad \\text{for all } i \\in \\mathcal{I}(s,a).\n", + "$$\n", + "\n", + "Only the weights corresponding to **active tiles** are updated.\n", + "\n", + "**Step-Size Scaling**\n", + "\n", + "Each state–action pair activates `n_tilings` features. \n", + "To prevent the total update magnitude from growing with the number of tilings, we scale the learning rate as:\n", + "$$\n", + "\\alpha_{\\text{effective}} = \\frac{\\alpha}{n_{\\text{tilings}}}.\n", + "$$\n", + "\n", + "This is standard practice when using tile coding and improves learning stability.\n", + "\n", + "**Action Selection: $\\varepsilon$-Greedy Policy**\n", + "\n", + "The agent follows an **$\\varepsilon$-greedy policy** with respect to $\\hat q(s,a)$:\n", + "\n", + "- with probability $\\varepsilon$: select a random action (exploration),\n", + "- with probability $1-\\varepsilon$: select an action maximizing $\\hat q(s,a)$ (exploitation),\n", + "- ties are broken uniformly at random.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "ac7510f4-0347-4475-af65-640535642809", + "metadata": {}, + "source": [ + "**Exercise 2.** Complete the following code cell to implement the **SARSA algorithm** for the **Mountain Car** problem. There are **only 3 `# TODO` items** to do.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b5bdc668-4006-4d2b-b473-e10261fa8221", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the discrete action set for Mountain Car.\n", + "# We keep the environment's natural action encoding:\n", + "# -1 : push left\n", + "# 0 : no push\n", + "# +1 : push right\n", + "ACTIONS = np.array([-1, 0, +1], dtype=int)\n", + "\n", + "\n", + "class SarsaAgent:\n", + " r\"\"\"Semi-gradient SARSA agent with linear function approximation for q(s,a) tile coding to build sparse feature representations phi(s,a).\n", + "\n", + " -----------------------------\n", + " 1) Function approximation\n", + " -----------------------------\n", + " We approximate the action-value function q_pi(s,a) by a parameterized function:\n", + " \\hat q(s,a; w) = w^T phi(s,a)\n", + "\n", + " In tile coding, phi(s,a) is a high-dimensional sparse binary vector:\n", + " - dimension can be large\n", + " - but only a small number of entries are 1\n", + " - specifically: exactly n_tilings active entries (one per tiling)\n", + "\n", + " Therefore, we can compute hat q using\n", + " \\hat q(s,a) = sum_{i in active(s,a)} w_i\n", + "\n", + " And the gradient is also simple:\n", + " gradient_w \\hat q(s,a) = phi(s,a)\n", + " which means:\n", + " - gradient is 1 on the active indices\n", + " - gradient is 0 everywhere else\n", + "\n", + " -----------------------------\n", + " 2) SARSA update rule\n", + " -----------------------------\n", + " SARSA is an on-policy TD control method. \"Semi-gradient\" means\n", + " - we treat the target as a constant w.r.t. w\n", + "\n", + " TD error (delta):\n", + " delta = r + gamma hat q(s',a') - hat q(s,a) if not terminal\n", + " delta = r - hat q(s,a) if terminal (since hat q(s',a') = 0)\n", + "\n", + " Weight update:\n", + " w_i <-- w_i + alpha delta for each active feature i of (s,a)\n", + "\n", + " -----------------------------\n", + " 3) Step-size scaling\n", + " -----------------------------\n", + " With tile coding, each (s,a) activates n_tilings features.\n", + " If we used the same alpha regardless of n_tilings, increasing n_tilings would\n", + " increase the total update magnitude per time step (more weights change).\n", + " To keep learning stable, common practice is:\n", + " alpha_effective = alpha / n_tilings\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " tilecoder: TileCoder,\n", + " alpha: float = 0.5,\n", + " gamma: float = 1.0,\n", + " epsilon: float = 0.0,\n", + " seed: int = 0,\n", + " ) -> None:\n", + " \"\"\"Initialize the SARSA agent with given parameters.\"\"\"\n", + " # Store the tile coder object.\n", + " # This object converts continuous states (x,v) + action into active indices.\n", + " self.tc = tilecoder\n", + "\n", + " # Discount factor gamma in [0,1].\n", + " # For episodic tasks like Mountain Car, gamma is often set to 1.0.\n", + " self.gamma = float(gamma)\n", + "\n", + " # Exploration parameter epsilon for epsilon-greedy policy.\n", + " self.epsilon = float(epsilon)\n", + "\n", + " # for reproducibility.\n", + " self.rng = np.random.default_rng(seed)\n", + "\n", + " # Scale the learning rate by 1 / n_tilings.\n", + " self.alpha = float(alpha) / self.tc.n_tilings\n", + "\n", + " # Initialize the parameter vector (weights) w in Rd.\n", + " self.w = np.zeros(self.tc.d, dtype=np.float64)\n", + "\n", + " def q(self, s: np.ndarray, a: int) -> float:\n", + " \"\"\"Compute the approximated action-value hat q.\n", + "\n", + " Because tile coding features are sparse:\n", + " - encode(s,a) returns the indices of active features\n", + " - hat q(s,a) is the sum of weights at these indices\n", + " \"\"\"\n", + " # Get the indices of the active tiles for (s,a):\n", + " # idx has shape (n_tilings,).\n", + " idx = self.tc.encode(s, a)\n", + "\n", + " # Sum the corresponding weights. This equals w^T phi(s,a)\n", + " # because phi(s,a) has value 1 at these indices and 0 elsewhere.\n", + " return float(self.w[idx].sum())\n", + "\n", + " def eps_greedy(self, s: np.ndarray) -> int:\n", + " \"\"\"Choose an action using an epsilon-greedy policy w.r.t. hat q.\n", + "\n", + " Policy definition:\n", + " - with probability epsilon: take a random action (exploration)\n", + " - with probability 1-epsilon: take a greedy action (exploitation)\n", + "\n", + " Tie-breaking:\n", + " - if multiple actions share the same maximal hat q(s,a), choose uniformly among them\n", + " \"\"\"\n", + " # If it is less than epsilon, we explore.\n", + " if self.rng.random() < self.epsilon:\n", + " # Choose a random action from ACTIONS uniformly.\n", + " return int(self.rng.choice(ACTIONS))\n", + "\n", + " # Otherwise, we exploit: compute hat q(s,a) for each possible action.\n", + " # This creates a length-3 array of q-values in the order of ACTIONS.\n", + " qs = np.array([self.q(s, int(a)) for a in ACTIONS], dtype=np.float64)\n", + "\n", + " # Identify the maximal q-value.\n", + " # qs.max() returns the best value; we then find which actions achieve it.\n", + " best = np.flatnonzero(qs == qs.max())\n", + "\n", + " # If there is a unique best action, best has length 1.\n", + " # If there is a tie, best contains multiple indices.\n", + " # We sample one index uniformly from best to break ties fairly.\n", + " return int(ACTIONS[self.rng.choice(best)])\n", + "\n", + " def update( # noqa: PLR0913\n", + " self, s: np.ndarray, a: int, r: float, sp: np.ndarray, ap: int, done: bool, # noqa: FBT001\n", + " ) -> float:\n", + " \"\"\"Perform one semi-gradient SARSA update.\n", + "\n", + " Inputs:\n", + " s : current state\n", + " a : current action\n", + " r : reward observed after taking a in s\n", + " sp : next state s'\n", + " ap : next action a' chosen by the current policy\n", + " done : whether s' is terminal\n", + "\n", + " Steps:\n", + " 1) Compute current estimate hat q(s,a)\n", + " 2) Compute target:\n", + " r if terminal\n", + " r + gamma* hat q(s',a') otherwise\n", + " 3) TD error delta = target - hat q(s,a)\n", + " 4) Update only the active weights for (s,a): w[idx] <-- w[idx] + alpha delta\n", + " \"\"\"\n", + " # Get active feature indices for (s,a).\n", + " # Only these weights contribute to hat q(s,a) and only these weights are updated.\n", + " idx = self.tc.encode(s, a)\n", + "\n", + " # Compute current hat q(s,a) efficiently as a sum of active weights.\n", + " qsa = float(self.w[idx].sum())\n", + "\n", + " # Compute the TD target.\n", + " if done:\n", + " # If next state is terminal, by definition there is no future return.\n", + " # So the target is just the immediate reward r.\n", + " target = r\n", + " else:\n", + " # Otherwise, bootstrap from the next state's action-value hat q(s',a').\n", + " # Note: ap must be the action actually selected by the current policy,\n", + " # which is why SARSA is \"on-policy\".\n", + " qspap = self.q(sp, ap)\n", + " target = r + self.gamma * qspap\n", + "\n", + " # TD error delta\n", + "\n", + " delta = target - qsa\n", + "\n", + " # Semi-gradient update:\n", + " # For linear approximation, the gradient w.r.t. active weights is 1.\n", + " # Therefore each active weight receives the same additive update alpha*delta.\n", + " #\n", + " # Important: because idx has length n_tilings, this single line updates\n", + " # exactly n_tilings weights.\n", + " self.w[idx] += self.alpha * delta\n", + "\n", + " # Return delta\n", + " return delta\n" + ] + }, + { + "cell_type": "markdown", + "id": "a7e16c48", + "metadata": {}, + "source": [ + "## 4. Training loop and learning curves\n", + "\n", + "We measure performance by **episode length** (number of steps to reach the goal).\n", + "Since reward is -1 per step, shorter episodes = higher return.\n", + "\n", + "We implement the training loop below and then run experiments. implement `run_episode` and `train`, then plot the learning curve.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d86f53a6", + "metadata": {}, + "outputs": [], + "source": [ + "def run_episode(\n", + " env: MountainCar, agent: SarsaAgent, max_steps: int = 10000,\n", + ") -> tuple[int, float]:\n", + " \"\"\"Run one episode with semi-gradient SARSA.\n", + "\n", + " Algorithmic structure matches Sutton & Barto:\n", + " - choose A from epsilon-greedy policy\n", + " - for each step: take A, observe (R,S')\n", + " - if terminal: update with target R\n", + " - else: choose A' from epsilon-greedy, update with target R + gamma q(S',A')\n", + " - shift (S,A) <- (S',A')\n", + "\n", + " Returns:\n", + " steps: number of environment steps\n", + " G: total return (sum of rewards)\n", + "\n", + " \"\"\"\n", + " s = env.reset()\n", + " a = agent.eps_greedy(s)\n", + "\n", + " G = 0.0\n", + " for t in range(max_steps):\n", + " sp, r, done = env.step(a)\n", + " G += r\n", + "\n", + " if done:\n", + " agent.update(s, a, r, sp, ap=0, done=True) # ap unused when done\n", + " return t + 1, G\n", + "\n", + " ap = agent.eps_greedy(sp)\n", + " agent.update(s, a, r, sp, ap, done=False)\n", + "\n", + " s, a = sp, ap\n", + "\n", + " return max_steps, G\n", + "\n", + "\n", + "def train(\n", + " seed: int = 0,\n", + " episodes: int = 200,\n", + " tc_kwargs: dict | None = None,\n", + " agent_kwargs: dict | None = None,\n", + ") -> tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Train over multiple episodes and collect learning curves.\"\"\"\n", + " if tc_kwargs is None:\n", + " tc_kwargs = {}\n", + " if agent_kwargs is None:\n", + " agent_kwargs = {}\n", + "\n", + " env = MountainCar(seed=seed)\n", + " tc = TileCoder(**tc_kwargs)\n", + " agent = SarsaAgent(tc, seed=seed, **agent_kwargs)\n", + "\n", + " lengths = np.zeros(episodes, dtype=int)\n", + " returns = np.zeros(episodes, dtype=np.float64)\n", + "\n", + " for ep in range(episodes):\n", + " L, G = run_episode(env, agent)\n", + " lengths[ep] = L\n", + " returns[ep] = G\n", + "\n", + " return lengths, returns\n" + ] + }, + { + "cell_type": "markdown", + "id": "5b4b9fc8", + "metadata": {}, + "source": [ + "## 5. Run the baseline configuration and plot the learning curve. \n", + "\n", + "We set\n", + "- tile coder: `n_tilings=8`, `n_x=8`, `n_v=8`\n", + "- agent: `gamma=1.0`, `epsilon=0.0`\n", + "- try `alpha` in `{0.1, 0.2, 0.5}`\n", + "\n", + "Plot:\n", + "- episode lengths (optionally add a moving average)\n", + "\n", + "**Exercise 3.** Run the following code and answer\n", + "1. Why are the first episodes so long?\n", + "2. What behavior is required to solve Mountain Car?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "1618e521", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Baseline configuration\n", + "seed = 0\n", + "episodes = 200\n", + "\n", + "tc_kwargs = {\"n_tilings\": 8, \"n_x\": 8, \"n_v\": 8}\n", + "agent_kwargs = {\"alpha\": 0.5, \"gamma\": 1.0, \"epsilon\": 0.0}\n", + "\n", + "lengths, returns = train(\n", + " seed=seed,\n", + " episodes=episodes,\n", + " tc_kwargs=tc_kwargs,\n", + " agent_kwargs=agent_kwargs,\n", + ")\n", + "\n", + "# Plot episode lengths\n", + "plt.figure()\n", + "plt.plot(lengths, label=\"Episode length\")\n", + "\n", + "# Simple moving average for readability\n", + "window = 10\n", + "if len(lengths) >= window:\n", + " ma = np.convolve(lengths, np.ones(window) / window, mode=\"valid\")\n", + " plt.plot(np.arange(window - 1, episodes), ma, label=f\"{window}-ep moving avg\")\n", + "\n", + "plt.xlabel(\"Episode\")\n", + "plt.ylabel(\"Steps to goal (lower is better)\")\n", + "plt.title(\"Mountain Car learning curve (Semi-gradient SARSA + Tile Coding)\")\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "cda6f949", + "metadata": {}, + "source": [ + "## 6. Effect of step size $\\alpha$\n", + "\n", + "Compare several step sizes and plot them together. Compare several values of `alpha` (e.g., 0.1, 0.2, 0.5) and plot learning curves on the same figure.\n", + "\n", + "**Exercise 4.** What happens when $\\alpha$ is too small vs too large?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "2d0a5991", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "alphas = [0.1, 0.2, 0.5]\n", + "seed = 0\n", + "episodes = 200\n", + "\n", + "tc_kwargs = {\"n_tilings\": 8, \"n_x\": 8, \"n_v\": 8}\n", + "\n", + "plt.figure()\n", + "for alpha in alphas:\n", + " agent_kwargs = {\"alpha\": alpha, \"gamma\": 1.0, \"epsilon\": 0.0}\n", + " lengths, _ = train(\n", + " seed=seed,\n", + " episodes=episodes,\n", + " tc_kwargs=tc_kwargs,\n", + " agent_kwargs=agent_kwargs,\n", + " )\n", + " window = 10\n", + " ma = np.convolve(lengths, np.ones(window) / window, mode=\"valid\")\n", + " plt.plot(np.arange(window - 1, episodes), ma, label=f\"alpha={alpha}\")\n", + "\n", + "plt.xlabel(\"Episode\")\n", + "plt.ylabel(\"Steps to goal (moving avg, lower is better)\")\n", + "plt.title(\"Effect of step size\")\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "da6493b7", + "metadata": {}, + "source": [ + "## 7. Effect of the number of tilings\n", + "\n", + "We now study the impact of the number of tilings on learning performance.\n", + "\n", + "Compare different values of `n_tilings` in \n", + "$$\n", + "\\{1,\\;4,\\;8,\\;16\\},\n", + "$$\n", + "while keeping all other parameters fixed.\n", + "\n", + "**Exercise 5.**\n", + "1. Why can increasing the number of tilings improve learning performance?\n", + "2. What are the disadvantages of increasing the number of tilings?" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "6a92b8a9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tilings_list = [1, 4, 8, 16]\n", + "seed = 0\n", + "episodes = 200\n", + "alpha = 0.5\n", + "\n", + "plt.figure()\n", + "for n_tilings in tilings_list:\n", + " tc_kwargs = {\"n_tilings\": n_tilings, \"n_x\": 8, \"n_v\": 8}\n", + " agent_kwargs = {\"alpha\": alpha, \"gamma\": 1.0, \"epsilon\": 0.0}\n", + " lengths, _ = train(\n", + " seed=seed,\n", + " episodes=episodes,\n", + " tc_kwargs=tc_kwargs,\n", + " agent_kwargs=agent_kwargs,\n", + " )\n", + " window = 10\n", + " ma = np.convolve(lengths, np.ones(window) / window, mode=\"valid\")\n", + " plt.plot(np.arange(window - 1, episodes), ma, label=f\"n_tilings={n_tilings}\")\n", + "\n", + "plt.xlabel(\"Episode\")\n", + "plt.ylabel(\"Steps to goal (lower is better)\")\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61dd8ad6-149e-43d5-aa15-a7b94b8312be", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "studies", + "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.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}