From baf0d21a2557c8bf35de213b4a776b8fd70bda54 Mon Sep 17 00:00:00 2001 From: Arthur DANJOU Date: Tue, 25 Nov 2025 12:34:42 +0100 Subject: [PATCH] Implement feature X to enhance user experience and optimize performance --- ...h epsilon‑Greedy and Bernoulli Rewards.ipynb | 1019 +++++++++++++++++ 1 file changed, 1019 insertions(+) create mode 100644 M2/Reinforcement Learning/Lab 1 - Multi‑Armed Bandits with epsilon‑Greedy and Bernoulli Rewards.ipynb diff --git a/M2/Reinforcement Learning/Lab 1 - Multi‑Armed Bandits with epsilon‑Greedy and Bernoulli Rewards.ipynb b/M2/Reinforcement Learning/Lab 1 - Multi‑Armed Bandits with epsilon‑Greedy and Bernoulli Rewards.ipynb new file mode 100644 index 0000000..5a5b935 --- /dev/null +++ b/M2/Reinforcement Learning/Lab 1 - Multi‑Armed Bandits with epsilon‑Greedy and Bernoulli Rewards.ipynb @@ -0,0 +1,1019 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "32ccfd0d", + "metadata": {}, + "source": [ + "# Lab 1 — Multi‑Armed Bandits (ε‑Greedy, Bernoulli Rewards)\n" + ] + }, + { + "cell_type": "markdown", + "id": "aa7605d3", + "metadata": {}, + "source": [ + "\n", + "In this lab you will:\n", + "\n", + "1. Implement a Bernoulli K-armed bandit environment.\n", + "\n", + "2. Implement the $\\varepsilon$-greedy action-selection strategy.\n", + "\n", + "3. Compare performance for different values of $\\varepsilon$ (average reward, optimal-action rate, cumulative regret).\n", + "\n", + "4. Compare computation time of two update methods for estimating action values:\n", + "\n", + " - Naive sample mean: recompute the mean from *all* past rewards for that arm each time (memory heavy).\n", + " \n", + " - Incremental sample mean: constant-time update using the running average and sample size $n$.\n", + " \n", + " \n", + "**Bandit model.**\n", + "\n", + "- Each arm i has a fixed but unknown success probability $p_i$ (drawn from the probability distribution $\\mathcal{U}(0,1)$).\n", + "\n", + "- Pulling arm i yields reward $R\\in\\{0,1\\}$ with $\\mathbb{P}(R=1)=p_i$ (Bernoulli).\n" + ] + }, + { + "cell_type": "markdown", + "id": "76ca9110", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "id": "27e7f16e", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "id": "9205900c", + "metadata": {}, + "source": [ + "## Environment: Bernoulli K‑armed bandit" + ] + }, + { + "cell_type": "markdown", + "id": "0544e2ee", + "metadata": {}, + "source": [ + "We first use a class to define a bandit environment, which is an object that knows its arms and can produce rewards.\n", + "\n", + "-------\n", + "\n", + "What is a class in Python ? A class in Python is like a template for creating objects that have:\n", + "1. some data (variables),\n", + "2. and some behaviors (functions called methods).\n", + "\n", + "-------" + ] + }, + { + "cell_type": "markdown", + "id": "334e9036", + "metadata": {}, + "source": [ + "**Exercise 1.** Read the following cell and learn how we define the Bernoulli Bandit environment." + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "id": "d65a53a7", + "metadata": {}, + "outputs": [], + "source": [ + "MIN_ARMS = 2 # Minimum number of arms\n", + "\n", + "class BernoulliBanditK:\n", + " \"\"\"K-armed Bernoulli bandit environment.\n", + "\n", + " - We have K arms (slot machines).\n", + " - Each arm i has a hidden success probability p_i (drawn from Uniform(0,1)).\n", + " - When we pull arm i, we get a reward R that is either 0 or 1.\n", + " - P(R=1) = p_i\n", + " - P(R=0) = 1 - p_i\n", + " \"\"\"\n", + "\n", + " # -----------------------------------------------------------\n", + " # __init__ : runs automatically when we create the object\n", + " # -----------------------------------------------------------\n", + "\n", + " def __init__(self, k: int = 10) -> None:\n", + " \"\"\"Initialize (create) a new bandit environment.\n", + "\n", + " Parameters\n", + " ----------\n", + " k : int\n", + " Number of arms (default 10).\n", + "\n", + " \"\"\"\n", + " # A safety check: we need at least 2 arms.\n", + " assert k >= MIN_ARMS, \"Use at least 2 arms.\"\n", + "\n", + " # 'self' refers to this particular object we are creating.\n", + " self.k = k # store the number of arms inside the object\n", + "\n", + " # Generate the true success probabilities of each arm.\n", + " # Each p_i is drawn from a Uniform(0,1) distribution.\n", + " self.p = np.random.uniform(low=0.0, high=1.0, size=k)\n", + "\n", + " # After this, the bandit is ready to use! Think of self as “this bandit”.\n", + "\n", + " # -----------------------------------------------------------\n", + " # pull:\n", + " # When you pull an arm i, it gets reward = 1 with probability p_i,\n", + " # -----------------------------------------------------------\n", + "\n", + " def pull(self, arm: int) -> int:\n", + " \"\"\"Simulate pulling one of the K arms.\n", + "\n", + " Returns reward = 1 with probability p[arm], otherwise 0.\n", + " \"\"\"\n", + " # np.random.rand() generates a random number in [0,1).\n", + " # If it's smaller than p[arm], we count it as a success (reward=1).\n", + " return int(np.random.rand() < self.p[arm]) # here it gives a “manual Bernoulli”\n", + "\n", + " # -----------------------------------------------------------\n", + " # optimal_arm :\n", + " # gives the index of the largest element in self.p,\n", + " # and it tells us which arm is truly best.\n", + " # (This is for evaluation only — the learning agent can’t see this.)\n", + " # -----------------------------------------------------------\n", + "\n", + " def optimal_arm(self) -> int:\n", + " \"\"\"Index of the true best arm (largest p_i).\"\"\"\n", + " return int(np.argmax(self.p))\n", + "\n", + " # -----------------------------------------------------------\n", + " # optimal_mean :\n", + " # gives the largest p_i\n", + " # This is useful for computing regret, i.e.\n", + " # how much worse the agent’s reward is compared to always choosing the best arm.\n", + " # -----------------------------------------------------------\n", + "\n", + " def optimal_mean(self) -> float:\n", + " \"\"\"Mean reward of the true best arm (largest p_i).\"\"\"\n", + " return float(np.max(self.p))\n", + "\n", + " # -----------------------------------------------------------\n", + " # __repr__ is another special method (like __init__). #repr stands for \"representation.\"\n", + " # It controls what happens when you type the object name or print it:\n", + " # -----------------------------------------------------------\n", + "\n", + " def __repr__(self) -> str:\n", + " \"\"\"Return string representation of the bandit.\"\"\"\n", + " return f\"BernoulliBanditK(k={self.k}, p={np.array2string(self.p, precision=3)})\"" + ] + }, + { + "cell_type": "markdown", + "id": "a36f526c", + "metadata": {}, + "source": [ + "**Exercise 2.** Run the following cell and observe its output.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "id": "1957ee50", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BernoulliBanditK(k=5, p=[0.098 0.58 0.943 0.263 0.812])\n", + "Best arm: 2\n", + "Best success prob: 0.9434322326142984\n", + "Reward from arm 2 for one pull: 1\n" + ] + } + ], + "source": [ + "env = BernoulliBanditK(k=5)\n", + "print(env) # show the bandit's true probabilities\n", + "print(\"Best arm:\", env.optimal_arm()) # in [0,1,2,3,..., k-1]\n", + "print(\"Best success prob:\", env.optimal_mean())\n", + "print(\"Reward from arm 2 for one pull:\", env.pull(2))" + ] + }, + { + "cell_type": "markdown", + "id": "9827e6ec", + "metadata": {}, + "source": [ + "## ε-Greedy algorithm for action selection\n" + ] + }, + { + "cell_type": "markdown", + "id": "aa597aa3", + "metadata": {}, + "source": [ + "In reinforcement learning, the **ε-greedy strategy** is one of the simplest methods to balance the exploration–exploitation trade-off.\n", + "\n", + "- **Exploitation:** choose the action (or arm) with the current highest estimated value \n", + " $\\rightarrow$ use what you know to get the best immediate reward.\n", + "- **Exploration:** with a small probability ε, choose a random action \n", + " $\\rightarrow$ try something new to discover potentially better options.\n", + "\n", + "Formally, for a set of estimated action values $Q(a)$:\n", + "\n", + "$$\n", + "A_t =\n", + "\\begin{cases}\n", + "\\text{a random action}, & \\text{with probability } \\varepsilon, \\\\\n", + "\\arg\\max_a Q(a), & \\text{with probability } 1 - \\varepsilon.\n", + "\\end{cases}\n", + "$$\n", + "\n", + "### Algorithm steps\n", + "1. Generate a random number $u \\sim \\text{Uniform}(0,1)$.\n", + "2. If $u < \\varepsilon$: **explore** $\\rightarrow$ select a random arm.\n", + "3. Otherwise: **exploit** $\\rightarrow$ select any arm with the largest estimated value $ Q(a) $.\n", + "4. In case of ties (several arms with the same maximum value), choose uniformly at random among them.\n", + "\n", + "### Typical choices\n", + "- Small $\\varepsilon$ values (e.g., 0.01 or 0.1) $\\rightarrow$ mostly exploitation, little exploration.\n", + "- Large $\\varepsilon$ values (e.g., 0.3 or 0.5) $\\rightarrow$ more exploration, slower convergence.\n", + "- Sometimes we can choose $\\varepsilon$ which decreases over time ($\\varepsilon$-decay): explore more at the beginning, exploit more later.\n" + ] + }, + { + "cell_type": "markdown", + "id": "3873ecf9", + "metadata": {}, + "source": [ + "-------------------\n", + "\n", + "\n", + "**Exercise 3.** Define a function called `select_action_eps_greedy` that takes as input the estimated action values `Q` and the exploration rate `epsilon`, and returns the index of the selected arm.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "id": "1caeb5f8", + "metadata": {}, + "outputs": [], + "source": [ + "def select_action_eps_greedy(Q: np.ndarray, epsilon: float) -> int:\n", + " \"\"\"Select an action according to the ε-greedy strategy.\n", + "\n", + " With probability ε: explore (choose a random arm).\n", + " With probability 1-ε: exploit (choose an arm uniformly with the highest estimated value).\n", + "\n", + " Parameters\n", + " ----------\n", + " Q : array of shape (k,)\n", + " Current estimated values of each arm.\n", + " epsilon : float\n", + " Exploration probability ε in [0, 1].\n", + "\n", + " Returns\n", + " -------\n", + " action : int\n", + " The index of the selected arm.\n", + "\n", + " \"\"\"\n", + " # First, with probability ε: explore (choose a random arm).\n", + " if np.random.rand() < epsilon:\n", + " return np.random.randint(len(Q))\n", + "\n", + " # With probability 1−ε: exploit (choose an arm with the highest estimated value).\n", + " max_val = np.max(Q) # Compute the maximum value of the array Q and store it in the variable max_val\n", + " candidates = np.isclose(Q, max_val) # (see Hint) Find all positions in Q where the value equals max_val.\n", + "\n", + " return np.random.choice(candidates) # pick one of those best arms uniformly at random." + ] + }, + { + "cell_type": "markdown", + "id": "665f98f0", + "metadata": {}, + "source": [ + "*Hint for Exercise 3 (Part 1):* We can not use `np.argmax(Q)` here, because it only gives the first index with the maximum value in $Q$." + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "id": "db362826", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "Q_example = np.array([0.3, 0.5, 0.5, 0.2])\n", + "print(np.argmax(Q_example))" + ] + }, + { + "cell_type": "markdown", + "id": "ad2c0941", + "metadata": {}, + "source": [ + "*Hint for Exercise 3 (Part 2):* However, if we use the following expression, it returns all the indices of the maximum value in $Q$. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "id": "0b3c2a7d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2]\n" + ] + } + ], + "source": [ + "# Find the maximum estimated value\n", + "max_val = np.max(Q_example)\n", + "\n", + "# Compare each Q[i] with the maximum (returns True/False)\n", + "is_best = np.isclose(Q_example, max_val)\n", + "\n", + "# Extract the indices where the value is close to the maximum\n", + "candidates = np.where(is_best)[0]\n", + "\n", + "print(candidates)" + ] + }, + { + "cell_type": "markdown", + "id": "8cdb298d", + "metadata": {}, + "source": [ + "*Hint for Exercise 3 (Part 3):* Note: Why do we use `np.isclose()` instead of `Q_example == max_val`?\n", + "\n", + "Because of floating-point rounding errors. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "id": "6db80382", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ True, False])" + ] + }, + "execution_count": 184, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Q_example = np.array([0.1 + 0.2, 0.3])\n", + "Q_example == np.max(Q_example)" + ] + }, + { + "cell_type": "markdown", + "id": "5078d51f", + "metadata": {}, + "source": [ + "*Hint for Exercise 3 (Part 4):* It gives `array([ True, False])` even though both numbers should be equal mathematically (0.3 vs 0.30000000000000004). \n", + "\n", + "So `np.isclose()` is safer — it allows for tiny numerical differences due to rounding." + ] + }, + { + "cell_type": "markdown", + "id": "9231a38f", + "metadata": {}, + "source": [ + "## Two ways to estimate action reward $Q_i$\n", + "\n", + "To decide which arm to pull, the agent maintains an estimate $ Q_i $ of the expected reward for each arm $ i $. \n", + "After each pull, this estimate must be updated using the new observed reward.\n", + "\n", + "There are two common approaches to update the action-value estimates:\n", + "\n", + "### Notation\n", + "\n", + "- $ Q_i $: the estimated average reward of arm $ i $. \n", + "\n", + "\n", + "\n", + "- $ R_t^{(i)}$: the reward received at time step $ t $ when arm $i $ is pulled. \n", + " Each time we play arm $ i $, we observe a random reward $ R_t^{(i)} $ drawn from the arm’s underlying reward distribution.\n", + "\n", + "\n", + "- $ N_i $: the number of times arm $ i $ has been selected so far (up to the current time t). \n", + "\n", + "\n", + "\n", + "### Method 1 - Naive sample mean update\n", + "- Keep all past rewards for each arm.\n", + "- Recompute the mean from all past rewards after each new observation.\n", + " $$\n", + " Q_i = \\frac{1}{N_i}\\sum_{t=1}^{N_i} R_t^{(i)}\n", + " $$\n", + "- Conceptually simple, but inefficient:\n", + " - requires storing all past rewards,\n", + " - recomputes the average each time (O(N) per update).\n", + "\n", + "### Method 2 - Incremental update\n", + "- Keep only the **current average** and the **number of times** an arm was selected.\n", + "- Update the estimate using the new reward $ R_t $ with a single formula:\n", + " $$\n", + " Q_i \\leftarrow Q_i + \\frac{1}{N_i}\\big(R_t - Q_i\\big)\n", + " $$\n", + "- Much faster and memory-efficient (O(1) per update).\n", + "\n", + "\n", + "Both approaches give the same result mathematically, but the incremental one is preferred in practice.\n", + "\n", + "-----------------------------------" + ] + }, + { + "cell_type": "markdown", + "id": "78e7cf17", + "metadata": {}, + "source": [ + "**Exercise 4.** Write a function called `update_naive` that takes as input the list of rewards for each arm `lists_of_rewards`, the selected arm index `a`, the received reward `r`, and the array of estimated values `Q`, and updates `Q[a]` with Method 1 Naive update. \n", + "\n", + "\n", + "*Hint.* Method 1: Naive update: `update_naive(...)`\n", + "\n", + "`lists_of_rewards` is a Python list of length $K$, where each element stores all past rewards obtained from that arm.\n", + "\n", + "\n", + "When we receive a new reward $r$ from arm $a$, we append it to that arm’s list.\n", + "Then, we recompute the average of all past rewards for that arm and store it in `Q[a]` as the new estimate of its action value.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 185, + "id": "ec070cbc", + "metadata": {}, + "outputs": [], + "source": [ + "def update_naive(lists_of_rewards, a: int, r: float, Q: np.ndarray) -> None:\n", + " \"\"\"Update the action-value estimate Q[a] using the new reward r.\"\"\"\n", + " lists_of_rewards[a].append(r)\n", + " Q[a] = np.mean(lists_of_rewards[a])" + ] + }, + { + "cell_type": "markdown", + "id": "8789ba5f", + "metadata": {}, + "source": [ + "\n", + "----------------\n", + "\n", + "\n", + "**Exercise 5.** Write a function called `update_incremental` that takes as input the array of estimated values `Q`, the array of counts `N`, the selected arm index `a`, and the received reward `r`, and updates `Q[a]` incrementally using the new reward by Method 2 Incremental update.\n", + "\n", + "*Hint.* Method 2: Incremental update: `update_incremental(...)`\n", + "\n", + "Instead of storing all past rewards, we can update each estimate $Q_i$ incrementally using only the most recent reward. \n", + "This method keeps a running average that gradually incorporates new information. \n", + "It requires only two arrays:\n", + "- `Q`: current estimated values of each arm \n", + "- `N`: the number of times each arm has been selected \n", + "\n", + "Each time we observe a new reward $r $ from arm $ a $, we increase its count `N[a]` and update the estimate `Q[a]` using a simple formula derived from the sample mean.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "id": "d4880f08", + "metadata": {}, + "outputs": [], + "source": [ + "def update_incremental(Q: np.ndarray, N: np.ndarray, a: int, r: float) -> None:\n", + " \"\"\"Incremental update of the action-value estimate Q[a] using the new reward r.\"\"\"\n", + " N[a] += 1\n", + " Q[a] += (r - Q[a]) / N[a]" + ] + }, + { + "cell_type": "markdown", + "id": "4c6c73bd", + "metadata": {}, + "source": [ + "## Running one ε‑greedy experiment (single run)\n", + "\n", + "\n", + "In this section, we simulate *one complete ε-greedy experiment* on the Bernoulli bandit environment. \n", + "The function `run_once()` runs the agent for **T time steps**, using a given exploration rate $\\varepsilon$ and a chosen update method (either `\"naive\"` or `\"incremental\"`).\n", + "\n", + "\n", + "At each time step:\n", + "\n", + "\n", + "1. The agent selects an arm using the $\\varepsilon$-greedy strategy. \n", + "\n", + "\n", + "2. It pulls that arm and receives a reward from the environment. \n", + "\n", + "\n", + "3. The corresponding action value $Q_a$ is updated using the chosen update rule. \n", + "\n", + "\n", + "4. We record:\n", + "\n", + "\n", + "- the obtained reward,\n", + " \n", + " \n", + "- whether the optimal arm was selected,\n", + " \n", + "\n", + "- and the *regret at each step*, which measures how much reward the agent missed compared to always choosing the best arm:\n", + " \n", + "$$\\text{regret}_t = p^* - R_t,$$\n", + " \n", + "where $ p^* $ is the true mean of the best arm.\n", + "\n", + "\n", + "The function returns all recorded results (rewards, regret, and optimal-action indicators) in a dictionary, \n", + "so we can later compute averages and visualize learning performance.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "id": "c656fbf9", + "metadata": {}, + "outputs": [], + "source": [ + "def run_once(T: int, epsilon: float, k: int = 10, update_style: str = \"incremental\"):\n", + " \"\"\"Run one full experiment of T time steps using ε-greedy on a k-armed Bernoulli bandit.\n", + "\n", + " Args:\n", + " T (int): number of steps in this run\n", + " epsilon (float): exploration probability for ε-greedy\n", + " k (int, optional): number of arms. Defaults to 10.\n", + " update_style (str, optional): \"incremental\" (default) or \"naive\" to choose the update rule.\n", + "\n", + " Returns:\n", + " dict: results of the run\n", + "\n", + " \"\"\"\n", + " env = BernoulliBanditK(k=k) # Create a new bandit environment with k arms.\n", + "\n", + " # For evaluation only (not used by the agent),\n", + " opt_arm = env.optimal_arm() # the index of the truly best arm which has the largest p_i\n", + " opt_mean = env.optimal_mean() # the best true success probability p_i\n", + "\n", + " if hasattr(opt_mean, \"item\"):\n", + " opt_mean = opt_mean.item()\n", + "\n", + " # -------------------------------------------------\n", + " # Initialize the action-value estimates Q_i to 0 for all arms.\n", + " Q = np.zeros(k, dtype=float)\n", + "\n", + " # record what happens at each time step\n", + " rewards = np.zeros(T, dtype=float) # rewards[t] = observed reward at step t (0 or 1),\n", + " chose_opt = np.zeros(T, dtype=float) # chose_opt[t] = 1 if the chosen arm equals opt_arm, else 0,\n", + " regret = np.zeros(T, dtype=float) # regret[t]=p^*-R_t, which means how much we “missed” compared to the best arm\n", + "\n", + " # -------------------------------------------------\n", + " # For the naive method,\n", + " # we keep all past rewards per arm in lists,\n", + " # so we can recompute the average from the full history each time.\n", + " # -------------------------------------------------\n", + "\n", + " # Initialisation pour la méthode naive\n", + " reward_lists = [[] for _ in range(k)] if update_style == \"naive\" else None\n", + " # Initialisation pour la méthode incrémentale\n", + " N = np.zeros(k, dtype=int) if update_style != \"naive\" else None\n", + "\n", + " for t in range(T):\n", + " if np.random.rand() < epsilon:\n", + " a = np.random.randint(k)\n", + " else:\n", + " max_val = np.max(Q)\n", + " candidates = np.where(np.isclose(Q, max_val))[0]\n", + " a = np.random.choice(candidates)\n", + " # ---------------------------------------------------------------------------------------\n", + " raw_reward = env.pull(a)\n", + " r = raw_reward.item() if hasattr(raw_reward, \"item\") else raw_reward\n", + "\n", + " rewards[t] = r\n", + " chose_opt[t] = 1.0 if a == opt_arm else 0.0\n", + " regret[t] = opt_mean - r\n", + "\n", + " if update_style == \"naive\":\n", + " update_naive(reward_lists, a, r, Q)\n", + " else:\n", + " update_incremental(Q, N, a, r)\n", + "\n", + " return {\n", + " \"p\": env.p,\n", + " \"optimal_arm\": opt_arm,\n", + " \"optimal_mean\": opt_mean,\n", + " \"rewards\": rewards,\n", + " \"optimal_selected\": chose_opt,\n", + " \"regret\": regret,\n", + " }\n", + "\n", + "\n", + "# for the return part, we package all useful outputs in a dictionary:\n", + "# p: the true probabilities\n", + "# optimal_*: the true values for evaluation,\n", + "# rewards, optimal_selected, regret: per-step logs we will average/plot later." + ] + }, + { + "cell_type": "markdown", + "id": "7cab885e", + "metadata": {}, + "source": [ + "## Averaging curves over many random runs\n", + "\n", + "In a single $\\varepsilon$-greedy run, the results depend on random factors such as the sampled arm probabilities and the random exploration choices. \n", + "To obtain *smooth and reliable performance curves*, we repeat the experiment many times \n", + "and average the results over all runs.\n", + "\n", + "\n", + "-------------------\n", + "\n", + "\n", + "\n", + "**Exercise 6.** Write a function called `run_many` that takes as input the number of runs `runs`, the number of time steps per run `T`, the exploration rate `epsilon`, the number of arms `k`, and the update rule `update_style` (\"incremental\" or \"naive\"). The function should return the average reward, the average rate of optimal action selection, and the average cumulative regret across all runs.\n", + "\n", + "\n", + "*Hint.* The function `run_many()` performs this averaging process:\n", + "\n", + "1. It runs the same experiment (`run_once`) several times (given by `runs`).\n", + "\n", + "2. For each time step, it accumulates:\n", + "\n", + " - the average reward,\n", + " \n", + " - the probability of selecting the optimal arm,\n", + " \n", + " - and the cumulative regret (sum of regrets up to that point).\n", + " \n", + "3. Finally, it divides the totals by the number of runs to get the mean curves.\n", + "\n", + "The returned arrays represent the *average learning behavior* of the $\\varepsilon$-greedy agent across many independent experiments.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "8fada515", + "metadata": {}, + "outputs": [], + "source": [ + "def run_many(\n", + " runs: int, T: int, epsilon: float, k: int, update_style: str = \"incremental\"\n", + "):\n", + " \"\"\"Run multiple independent experiments of T time steps using ε-greedy on a k-armed Bernoulli bandit.\n", + "\n", + " Args:\n", + " runs (int): number of independent repetitions of the full experiment\n", + " T (int): number of steps in each run\n", + " epsilon (float): exploration probability for ε-greedy\n", + " k (int): number of arms\n", + " update_style (str): \"incremental\" (default) or \"naive\" to choose the update rule\n", + "\n", + " \"\"\"\n", + " results = []\n", + " for _run in range(runs):\n", + " res = run_once(T, epsilon, k, update_style)\n", + " results.append(res)\n", + "\n", + " avg_rewards = np.mean([res[\"rewards\"] for res in results], axis=0)\n", + " avg_optimal = np.mean([res[\"optimal_selected\"] for res in results], axis=0)\n", + " avg_instant_regret = np.mean([res[\"regret\"] for res in results], axis=0)\n", + "\n", + " return avg_rewards, avg_optimal, np.cumsum(avg_instant_regret)\n" + ] + }, + { + "cell_type": "markdown", + "id": "41bf4e6a", + "metadata": {}, + "source": [ + "-------------------\n", + "\n", + "\n", + "## Experiment 1 — $\\varepsilon$ comparison (incremental updates)\n", + "\n", + "\n", + "This section runs the $\\varepsilon$ -greedy algorithm with different exploration rates ($\\varepsilon$) and compares their performance.\n", + "It shows how $\\varepsilon$ affects learning by plotting:\n", + "\n", + "1. the average reward over time,\n", + "\n", + "2. the probability of selecting the optimal arm,\n", + "\n", + "3. the average cumulative regret.\n", + "\n", + "The goal is to visualize the exploration–exploitation trade-off.\n", + "\n", + "**Question : Which ε gives the best performance overall, and why?**" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "id": "595184b1", + "metadata": {}, + "outputs": [], + "source": [ + "K = 10 # number of arms in the bandit.\n", + "T = 1000 # number of time steps per experiment.\n", + "RUNS = 300 # number of independent runs to average results\n", + "eps_list = [0.0, 0.01, 0.1, 0.3] # list of epsilon values to test.\n", + "\n", + "# ----------------------------------------------\n", + "\n", + "# For each epsilon:\n", + "# Call run_many() to perform 300 averaged runs of epsilon-greedy with that epsilon value.\n", + "# Store the resulting averaged curves in a dictionary:\n", + "# \"avg_reward\" : average reward per step,\n", + "# \"avg_opt\" : probability of selecting the optimal arm,\n", + "# \"avg_cumreg\" : average cumulative regret.\n", + "\n", + "results = {}\n", + "for eps in eps_list:\n", + " ar, ao, cr = run_many(runs=RUNS, T=T, epsilon=eps, k=K, update_style=\"incremental\")\n", + " results[eps] = {\"avg_reward\": ar, \"avg_opt\": ao, \"avg_cumreg\": cr}" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "id": "3aa46e4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot: Average reward\n", + "colors = sns.color_palette(\"magma\", len(eps_list))\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "for eps in eps_list:\n", + " plt.plot(results[eps][\"avg_reward\"], label=f\"ε={eps}\", color=colors[eps_list.index(eps)])\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"Average reward\")\n", + "plt.title(\"Average reward vs step (Bernoulli bandit, ε-greedy)\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Plot: Probability of optimal action\n", + "plt.figure(figsize=(10, 6))\n", + "for eps in eps_list:\n", + " plt.plot(results[eps][\"avg_opt\"], label=f\"ε={eps}\", color=colors[eps_list.index(eps)])\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"P(select optimal arm)\")\n", + "plt.title(\"Optimal-action probability vs step (ε-greedy)\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Plot: Cumulative rewards vs step\n", + "plt.figure(figsize=(10, 6))\n", + "for eps in eps_list:\n", + " cum_rewards = np.cumsum(results[eps][\"avg_reward\"])\n", + " plt.plot(cum_rewards, label=f\"ε={eps}\", color=colors[eps_list.index(eps)])\n", + "\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"Cumulative reward\")\n", + "plt.title(\"Cumulative reward vs step (ε-greedy)\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "\n", + "# Plot: Cumulative regret\n", + "plt.figure(figsize=(10, 6))\n", + "for eps in eps_list:\n", + " plt.plot(results[eps][\"avg_cumreg\"], label=f\"ε={eps}\", color=colors[eps_list.index(eps)])\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"Average cumulative regret\")\n", + "plt.title(\"Cumulative regret vs step (ε-greedy)\")\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4302bab9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "0a44b148", + "metadata": {}, + "source": [ + "### Discussion: Which ε gives the best performance overall?\n", + "\n", + "By looking at the four graphes, we select the best $\\epsilon = 0.1$ as it has the best average reward vs step, the best optimal-action probability, the best cumulative reward " + ] + }, + { + "cell_type": "markdown", + "id": "04f66bdf", + "metadata": {}, + "source": [ + "-------------------\n", + "\n", + "\n", + "## Experiment 2 — Computation time: naive vs incremental sample mean\n", + "\n", + "In this experiment, we compare the computational efficiency of the two update methods:\n", + "- the *naive update*, which recomputes the average from all past rewards each time, and \n", + "- the *incremental update*, which adjusts the mean using only the latest reward.\n", + "\n", + "Although both methods produce exactly the same estimates $ Q_i $, their computation time differs greatly.\n", + "\n", + "The code below measures the total runtime of each method over many steps and reports:\n", + "- the total execution time for both methods, and \n", + "- the speedup ratio, showing how many times faster the incremental update is compared to the naive one.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "id": "49ff8e7e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive sample-mean total time over 2 runs × 100000 steps: 214.286 s\n", + "Incremental sample-mean total time over 2 runs × 100000 steps: 2.498 s\n", + "Speedup (naive / incremental): 85.77×\n" + ] + } + ], + "source": [ + "K = 10\n", + "T_time = 100000 # adjust based on machine\n", + "EPS = 0.1\n", + "RUNS_num = 2 # average timings\n", + "\n", + "\n", + "def time_runner(update_style: str) -> float:\n", + " \"\"\"Run the bandit algorithm and measure the time taken.\n", + "\n", + " Args:\n", + " update_style (str): The update style to use (\"naive\" or \"incremental\").\n", + "\n", + " Returns:\n", + " float: The total time taken to run the algorithm.\n", + "\n", + " \"\"\"\n", + " t0 = time.perf_counter()\n", + " for _ in range(RUNS_num):\n", + " _ = run_once(T=T_time, epsilon=EPS, k=K, update_style=update_style)\n", + " t1 = time.perf_counter()\n", + " return t1 - t0\n", + "\n", + "\n", + "t_naive = time_runner(\"naive\")\n", + "t_incr = time_runner(\"incremental\")\n", + "\n", + "print(\n", + " f\"Naive sample-mean total time over {RUNS_num} runs × {T_time} steps: {t_naive:.3f} s\"\n", + ")\n", + "print(\n", + " f\"Incremental sample-mean total time over {RUNS_num} runs × {T_time} steps: {t_incr:.3f} s\"\n", + ")\n", + "print(f\"Speedup (naive / incremental): {t_naive / t_incr:.2f}×\")" + ] + }, + { + "cell_type": "markdown", + "id": "c4b6e959-d601-493a-9b74-2c60d87fb085", + "metadata": {}, + "source": [ + "\n", + "**Optional exercise**\n", + "\n", + "If you’re curious to go further, try experimenting with \n", + "\n", + "1. **Optimistic Initial Values:** \n", + " Initialize all action-value estimates `Q[i]` with a high value (e.g., `Q0 = 2` or `5`) and set `ε = 0`. \n", + " Observe how the agent still explores different arms at the beginning and then focuses on the best one as estimates decrease.\n", + "\n", + "2. **Upper-Confidence-Bound (UCB):** \n", + " Use the rule \n", + " $$\n", + " A_t = \\arg\\max_i \\Big[ Q_i(t) + c \\sqrt{\\tfrac{\\ln t}{N_i(t)}} \\Big],\n", + " $$\n", + " where \\(c>0\\) controls how much to explore. \n", + " Try different values of `c` (e.g., `0.5`, `1`, `2`) and compare the results with ε-greedy.\n", + "\n", + "**Question:** \n", + "How do these strategies differ from ε-greedy in terms of exploration behavior and learning speed? \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe2fc921-aa95-49d5-8cbe-60a800444ff7", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}