{ "cells": [ { "cell_type": "markdown", "id": "2acbf1b7", "metadata": {}, "source": [ "# Ch 01 — The ML Landscape (notebook)\n", "\n", "`[← 00 math-and-python-prereqs]` · **this notebook** · `[02 end-to-end-ml-project →]`\n", "\n", "Runs top-to-bottom in ~1 min on free Colab CPU. Last verified 2026-06-11.\n", "\n", "**What you'll build**\n", "- A life-satisfaction-vs-GDP model on a tiny vendored dataset, fit two ways: instance-based (k-NN) and model-based (a line), checked against scikit-learn.\n", "- The sampling-bias reveal: a line that fits a hand-picked slice of countries beautifully, then collapses the moment the poorer and richer countries are added back.\n", "- The overfitting reveal: a high-degree polynomial that nails every training point and is useless off it, watched live on a train-vs-validation U-curve.\n", "- An unsupervised clustering of the same countries with the labels hidden, and a learned decision boundary for \"happy vs not\", drawn as an image.\n", "- A runnable three-axis problem classifier (supervision · batch/online · instance/model) that turns the chapter's taxonomy into code.\n", "\n", "**How this notebook works.** Code cells with a `# TODO` are yours to fill in. Run the cell to grade yourself: `[ ok ]` passed, `[FAIL]` shows what went wrong, `[ -- ]` means not attempted yet. Every exercise has a hint ladder (open only as many as you need) and a folded solution below it. The notebook runs top-to-bottom even if you fill in nothing: the solution cells redefine the functions so the later cells work. See Ch 00 for the full protocol.\n" ] }, { "cell_type": "markdown", "id": "689fefa3", "metadata": {}, "source": [ "## Before you start\n", "\n", "1. Tom Mitchell defines learning as improving at a task `T`, measured by `P`, with experience `E`. For a spam filter, name `T`, `P`, and `E`.
Answer`T` = label an email spam or not; `P` = some error metric (say, the misclassification rate, or precision/recall); `E` = a corpus of emails already labelled spam / not-spam. If you cannot name all three, the claim \"we trained a model\" is incomplete.
\n", "2. You fit a straight line to 7 carefully chosen data points and it passes almost exactly through all of them. Is that good news?
AnswerNot yet. A clean fit on a small hand-picked sample is exactly what sampling bias and overfitting look like from the inside. The only honest test is held-out data you did not choose. This whole notebook is built around that one lesson.
\n", "3. Predict before you run: as a country's GDP per capita rises, does reported life satisfaction rise without limit, level off, or fall?
AnswerIt rises steeply at low income then flattens: the marginal happiness per extra dollar shrinks. A straight line fit to only the rich middle of the range will look great and extrapolate badly, which is precisely the trap in Part 2.
\n" ] }, { "cell_type": "markdown", "id": "26808224", "metadata": {}, "source": [ "## Setup\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "b0b952de", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.032160Z", "iopub.status.busy": "2026-06-10T18:49:12.032082Z", "iopub.status.idle": "2026-06-10T18:49:12.667807Z", "shell.execute_reply": "2026-06-10T18:49:12.667401Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "numpy 2.2.6 · pandas 2.3.3 · sklearn 1.7.2\n" ] } ], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import sklearn\n", "print(f\"numpy {np.__version__} · pandas {pd.__version__} · sklearn {sklearn.__version__}\")\n", "if np.__version__ < \"2.0\":\n", " print(\"WARN: written for NumPy 2.x; older versions may differ in the last digit\")" ] }, { "cell_type": "code", "execution_count": 2, "id": "c77a70d2", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.668954Z", "iopub.status.busy": "2026-06-10T18:49:12.668803Z", "iopub.status.idle": "2026-06-10T18:49:12.673200Z", "shell.execute_reply": "2026-06-10T18:49:12.672785Z" } }, "outputs": [], "source": [ "import os, random\n", "SEED = 0\n", "FAST = bool(os.environ.get('NB_FAST')) # CI smoke mode: same code paths, fewer steps\n", "GRID = 60 if FAST else 200 # resolution of the decision-boundary image (cosmetic only)\n", "rng = np.random.default_rng(SEED)\n", "random.seed(SEED)\n", "\n", "# ── house self-check harness (identical across all chapter notebooks) ──\n", "import numpy as _np\n", "\n", "def check(label, test_fn, required=False):\n", " \"\"\"Run one self-check. test_fn raises AssertionError (with a teaching\n", " message) on failure, NotImplementedError if the stub is unfilled.\n", " required=True is used only in solution cells; it is what CI grades.\"\"\"\n", " try:\n", " test_fn()\n", " except NotImplementedError:\n", " if required:\n", " raise AssertionError(f\"{label}: reference solution incomplete\")\n", " print(f\"[ -- ] {label}: not attempted yet — fill in the TODO above, then re-run.\")\n", " return False\n", " except AssertionError as e:\n", " if required:\n", " raise\n", " print(f\"[FAIL] {label}: {e}\")\n", " return False\n", " print(f\"[ ok ] {label}\")\n", " return True\n", "\n", "def attempted(*vals):\n", " \"\"\"Treat None placeholders as 'not attempted'.\"\"\"\n", " if any(v is None for v in vals):\n", " raise NotImplementedError\n", "\n", "def check_shape(x, want):\n", " assert tuple(x.shape) == tuple(want), \\\n", " f\"shape {tuple(x.shape)}, expected {tuple(want)} — check your reshape/transpose order\"\n", "\n", "def check_close(got, want, atol=1e-5, rtol=1e-4, msg=\"\"):\n", " g, w = _np.asarray(got, dtype=float), _np.asarray(want, dtype=float)\n", " assert g.shape == w.shape, f\"shape {g.shape} vs expected {w.shape}. {msg}\"\n", " bad = ~_np.isclose(g, w, atol=atol, rtol=rtol)\n", " assert not bad.any(), \\\n", " f\"{bad.mean():.2%} of values wrong (max diff {abs(g - w).max():.3g}). {msg}\"" ] }, { "cell_type": "markdown", "id": "f638bbad", "metadata": {}, "source": [ "> **Note:** seeds make this notebook's printed numbers reproduce on CPU. Library versions and BLAS threading can shift the last digit or two; quoted numbers hold for the pinned environment. If a coefficient reads `4.91e-05` where the page says `4.9e-05`, you did nothing wrong.\n" ] }, { "cell_type": "markdown", "id": "4d7d1589", "metadata": {}, "source": [ "## The map\n", "\n", "> **Part 1 — What learning is, on real data.** Load the life-satisfaction-vs-GDP dataset, pin Mitchell's `T`/`P`/`E` to variables, and fit it two ways: instance-based (k-NN) and model-based (a line).\n", "> **Part 2 — The line that lies.** Fit a line to a hand-picked slice of countries, admire it, then add the countries that were quietly dropped and watch the story change. This is sampling bias you can see.\n", "> **Part 3 — Overfitting, watched live.** Push model capacity up with polynomial degree until the fit memorises the slice and fails off it. Read the train-vs-validation U-curve and pick the sweet spot.\n", "> **Part 4 — No labels, then a boundary.** Cluster the countries with the labels hidden (unsupervised), then learn a decision boundary for \"happy vs not\" and draw it as an image (supervised).\n", "> **Part 5 — The taxonomy as code.** Turn the three-axis picker (supervision · batch/online · instance/model) into a function and test it on real problem descriptions.\n" ] }, { "cell_type": "markdown", "id": "0643aad8", "metadata": {}, "source": [ "## Part 1 — What learning is, on real data\n", "\n", "> **Objectives.** Pin Mitchell's definition to actual variables. Fit the same data instance-based (k-NN, the model *is* the data) and model-based (a line, the model is a few parameters), and check both against scikit-learn.\n", "\n", "Tom Mitchell's 1997 definition is the one researchers actually use:\n", "\n", "> A computer program **learns** from experience `E` with respect to task `T` and performance measure `P`, if its performance on `T`, as measured by `P`, improves with `E`.\n", "\n", "Three things: a task, data, a metric. When someone says \"we trained a model\", the honest follow-up is always \"on what data, with what metric, for what task?\". We are going to make `T`, `P`, and `E` concrete on a dataset small enough to print.\n" ] }, { "cell_type": "markdown", "id": "1df48d28", "metadata": {}, "source": [ "### 1.1 The anchor dataset (vendored inline)\n", "\n", "The dataset is GDP per capita (US dollars, 2020) against life satisfaction (the OECD Better Life Index, a 0-10 self-report) for a set of countries. It is the example Aurélien Géron opens *Hands-On ML* with, and these are his published 2020 figures. We embed it as a string literal so the notebook runs with no network and no file to fetch. It is a frozen historical snapshot, not a live feed: the numbers will never change under you.\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "a0d0f307", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.674217Z", "iopub.status.busy": "2026-06-10T18:49:12.674134Z", "iopub.status.idle": "2026-06-10T18:49:12.681984Z", "shell.execute_reply": "2026-06-10T18:49:12.681601Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "36 countries, GDP 5,090-109,602 USD\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
countrygdp_per_capita_usdlife_satisfaction
0South Africa50904.7
1Colombia52076.3
2Brazil64506.4
3Mexico80696.5
4Turkey99465.5
\n", "
" ], "text/plain": [ " country gdp_per_capita_usd life_satisfaction\n", "0 South Africa 5090 4.7\n", "1 Colombia 5207 6.3\n", "2 Brazil 6450 6.4\n", "3 Mexico 8069 6.5\n", "4 Turkey 9946 5.5" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# The full table, embedded so the notebook is offline-proof. Tier-3 dataset\n", "# policy: anything under ~50KB is vendored as a literal rather than fetched.\n", "LIFESAT_CSV = \"\"\"country,gdp_per_capita_usd,life_satisfaction\n", "Turkey,9946,5.5\n", "Hungary,15372,5.6\n", "Poland,15732,6.1\n", "Slovenia,25739,6.5\n", "Estonia,23006,5.7\n", "Greece,17676,5.4\n", "Portugal,22405,5.4\n", "Spain,26831,6.3\n", "Italy,31676,6.0\n", "Lithuania,19266,5.9\n", "Latvia,17118,5.9\n", "Israel,42115,7.2\n", "Czechia,22627,6.7\n", "Slovak Republic,19266,6.2\n", "France,39257,6.5\n", "United Kingdom,40229,6.8\n", "Belgium,42659,6.9\n", "Germany,45724,7.0\n", "Finland,48586,7.6\n", "Austria,48586,7.1\n", "Netherlands,52331,7.4\n", "Sweden,51242,7.3\n", "Denmark,55938,7.6\n", "Australia,51885,7.3\n", "Canada,43258,7.4\n", "United States,63414,6.9\n", "Norway,67390,7.6\n", "Switzerland,81867,7.5\n", "Ireland,79669,7.0\n", "Luxembourg,109602,6.9\n", "Colombia,5207,6.3\n", "Brazil,6450,6.4\n", "Mexico,8069,6.5\n", "Chile,12612,6.5\n", "Russia,9972,5.8\n", "South Africa,5090,4.7\n", "\"\"\"\n", "\n", "import io\n", "df = pd.read_csv(io.StringIO(LIFESAT_CSV)).sort_values(\"gdp_per_capita_usd\").reset_index(drop=True)\n", "print(f\"{len(df)} countries, GDP {df.gdp_per_capita_usd.min():,}-{df.gdp_per_capita_usd.max():,} USD\")\n", "df.head()" ] }, { "cell_type": "markdown", "id": "9f948917", "metadata": {}, "source": [ "> **Note:** these are Géron's published 2020 OECD/IMF figures, reproduced as a teaching fixture. Treat them as historical, not current. The point of this chapter is what you can and cannot conclude from a sample like this, which is timeless.\n" ] }, { "cell_type": "markdown", "id": "a4148381", "metadata": {}, "source": [ "### 1.2 Mitchell's definition, as variables\n", "\n", "Let the task be: predict life satisfaction from GDP per capita. The experience `E` is the table above. The performance measure `P` is the mean absolute error of the prediction, in satisfaction points. Pinning these to names is not pedantry: it is the difference between a claim you can test and one you cannot.\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "c9db85cb", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.682888Z", "iopub.status.busy": "2026-06-10T18:49:12.682808Z", "iopub.status.idle": "2026-06-10T18:49:12.685912Z", "shell.execute_reply": "2026-06-10T18:49:12.685516Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "baseline (predict the mean) MAE: 0.613 satisfaction points\n" ] } ], "source": [ "X = df[[\"gdp_per_capita_usd\"]].to_numpy(dtype=float) # (n, 1) feature: GDP per capita\n", "y = df[\"life_satisfaction\"].to_numpy(dtype=float) # (n,) target: 0-10 self-report\n", "\n", "def P(y_true, y_pred):\n", " \"\"\"Performance measure P: mean absolute error, in life-satisfaction points.\"\"\"\n", " return float(np.mean(np.abs(np.asarray(y_true) - np.asarray(y_pred))))\n", "\n", "# A trivial baseline: predict the mean satisfaction for everyone, ignore GDP.\n", "baseline = np.full_like(y, y.mean())\n", "print(f\"baseline (predict the mean) MAE: {P(y, baseline):.3f} satisfaction points\")" ] }, { "cell_type": "markdown", "id": "1918b71e", "metadata": {}, "source": [ "> **Interpretation.** The do-nothing baseline gets within about half a point on average. Any model that does not beat this number has learned nothing useful about GDP. Always compute the dumb baseline first; it is the bar every later number is measured against.\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "5e82c793", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.686709Z", "iopub.status.busy": "2026-06-10T18:49:12.686626Z", "iopub.status.idle": "2026-06-10T18:49:12.760988Z", "shell.execute_reply": "2026-06-10T18:49:12.760617Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# viz: the raw relationship, the thing every later model is trying to capture\n", "fig, ax = plt.subplots(figsize=(7, 4))\n", "ax.scatter(X[:, 0], y, color=\"#1E40FF\")\n", "ax.set_xlabel(\"GDP per capita (USD, 2020)\"); ax.set_ylabel(\"life satisfaction (0-10)\")\n", "ax.set_title(\"Life satisfaction vs GDP per capita\")\n", "plt.tight_layout(); plt.show()" ] }, { "cell_type": "markdown", "id": "ab38ecf0", "metadata": {}, "source": [ "> **Predict:** does this look like a straight line, or a curve that flattens?
AnswerIt rises fast at low income then bends over and flattens. A straight line is the wrong shape for the full range, but, as Part 2 shows, it can look perfect on a slice chosen from the middle.
\n" ] }, { "cell_type": "markdown", "id": "4d685f3a", "metadata": {}, "source": [ "### 1.3 Two ways to represent what you learned\n", "\n", "The draft splits algorithms by *how they store knowledge*:\n", "\n", "- **Instance-based.** The model *is* the training data. To predict, find the most similar stored examples and copy or average their labels. k-Nearest-Neighbours is the canonical case. Zero training time, but prediction reads the whole dataset and there is no compression into knowledge.\n", "- **Model-based.** Training distils the data into a few parameters `θ`. To predict, evaluate `f_θ(x)`. A straight line `ŷ = a·gdp + b` has two parameters. Fast, compact, and forced to commit to a functional shape.\n", "\n", "We fit both on the same data, then check each against scikit-learn so the comparison is not taken on faith.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "a32e31d4", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.762109Z", "iopub.status.busy": "2026-06-10T18:49:12.762018Z", "iopub.status.idle": "2026-06-10T18:49:12.792448Z", "shell.execute_reply": "2026-06-10T18:49:12.792132Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "line: satisfaction = 2.148e-05 * gdp + 5.776\n", "model-based (line) MAE: 0.429\n", "[ ok ] our line matches sklearn (slope 2.148e-05, intercept 5.776)\n" ] } ], "source": [ "# Model-based: a straight line, fit by the closed-form least-squares solution.\n", "# theta = [slope, intercept]; we solve the normal equations via np.linalg.lstsq.\n", "A = np.c_[X[:, 0], np.ones(len(X))] # design matrix (n, 2): [gdp, 1]\n", "theta, *_ = np.linalg.lstsq(A, y, rcond=None)\n", "slope, intercept = theta\n", "print(f\"line: satisfaction = {slope:.3e} * gdp + {intercept:.3f}\")\n", "print(f\"model-based (line) MAE: {P(y, A @ theta):.3f}\")\n", "\n", "# Cross-check against scikit-learn's LinearRegression: same math, independent code.\n", "from sklearn.linear_model import LinearRegression\n", "lin = LinearRegression().fit(X, y)\n", "check_close([lin.coef_[0], lin.intercept_], [slope, intercept], atol=1e-6,\n", " msg=\"our least-squares line should match sklearn's to 6 decimals\")\n", "print(f\"[ ok ] our line matches sklearn (slope {lin.coef_[0]:.3e}, intercept {lin.intercept_:.3f})\")" ] }, { "cell_type": "markdown", "id": "9d8c5ce3", "metadata": {}, "source": [ "> **Interpretation.** Two independent code paths, the same line. That agreement assert is the cheapest insurance in the notebook: if our hand-rolled math drifted, the cell would stop here with a message instead of quietly teaching the wrong thing.\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "b41741d8", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.793646Z", "iopub.status.busy": "2026-06-10T18:49:12.793563Z", "iopub.status.idle": "2026-06-10T18:49:12.804432Z", "shell.execute_reply": "2026-06-10T18:49:12.804164Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "instance-based (3-NN) MAE: 0.300\n", "model-based (line) MAE: 0.429\n" ] } ], "source": [ "# Instance-based: k-NN regression, the model that IS the data.\n", "from sklearn.neighbors import KNeighborsRegressor\n", "knn = KNeighborsRegressor(n_neighbors=3).fit(X, y)\n", "print(f\"instance-based (3-NN) MAE: {P(y, knn.predict(X)):.3f}\")\n", "print(f\"model-based (line) MAE: {P(y, lin.predict(X)):.3f}\")" ] }, { "cell_type": "markdown", "id": "a6859637", "metadata": {}, "source": [ "> **Common confusion:** k-NN's error here is low partly because we are scoring it on the very points it memorised; with `k=3` it half-copies its own neighbours. That is the instance-based trap, and it is the same trap as overfitting wearing a different coat. Part 2 and Part 3 score models on data they did *not* see, which is the only honest test.\n" ] }, { "cell_type": "markdown", "id": "786b34c5", "metadata": {}, "source": [ "### Exercise 1.1 — Predict for a country not in the table\n", "`Difficulty 1/5 · ~8 min`\n", "\n", "Cyprus had a GDP per capita of about 26,240 USD in 2020 and is not in our table. Write `predict_satisfaction(gdp, kind)` that returns a single predicted life-satisfaction number, using either the fitted line (`kind=\"model\"`) or 3-NN (`kind=\"instance\"`). The fitted `lin`, `knn`, `slope`, and `intercept` already exist above; you are calling them, not refitting.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "03f206fd", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.805619Z", "iopub.status.busy": "2026-06-10T18:49:12.805542Z", "iopub.status.idle": "2026-06-10T18:49:12.808987Z", "shell.execute_reply": "2026-06-10T18:49:12.808624Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] 1.1 predict (model + instance): not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def predict_satisfaction(gdp, kind=\"model\"):\n", " \"\"\"Predict life satisfaction for one GDP-per-capita value (a float).\"\"\"\n", " # TODO 1: for kind == \"model\", use the line: slope * gdp + intercept\n", " # TODO 2: for kind == \"instance\", call knn.predict on a (1, 1) array\n", " # (k-NN expects 2-D input: np.array([[gdp]]))\n", " result = None\n", " attempted(result)\n", " return float(result)\n", "\n", "def _ex11():\n", " g = 26240.0\n", " m = predict_satisfaction(g, \"model\")\n", " i = predict_satisfaction(g, \"instance\")\n", " assert 4.0 <= m <= 8.0, f\"model prediction {m:.2f} is off the 0-10 scale for a mid-income country\"\n", " assert 4.0 <= i <= 8.0, f\"instance prediction {i:.2f} is off the scale\"\n", " # the line is smooth, k-NN is a local average; they should not be identical\n", " assert abs(m - i) > 1e-9, \"model and instance predictions came out identical; did both branches run?\"\n", "\n", "check(\"1.1 predict (model + instance)\", _ex11)" ] }, { "cell_type": "markdown", "id": "2198ee33", "metadata": {}, "source": [ "
Hint 1 (conceptual)The model branch is one arithmetic line. The instance branch calls `knn.predict(...)` and pulls element `[0]` out of the returned array.
\n", "\n", "
Hint 2 (pseudocode)\n", "\n", "```python\n", "if kind == \"model\":\n", " result = slope * gdp + intercept\n", "elif kind == \"instance\":\n", " result = knn.predict(np.array([[gdp]]))[0]\n", "```\n", "
\n", "\n", "
Help — \"Expected 2D array, got 1D array instead\"scikit-learn estimators want a 2-D `(n_samples, n_features)` input even for one example. Wrap your scalar: `np.array([[gdp]])`, not `np.array([gdp])`.
\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "fc5677e2", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.809843Z", "iopub.status.busy": "2026-06-10T18:49:12.809768Z", "iopub.status.idle": "2026-06-10T18:49:12.812887Z", "shell.execute_reply": "2026-06-10T18:49:12.812516Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] 1.1 predict (model + instance)\n", "Cyprus (GDP 26,240): line says 6.34, 3-NN says 6.17\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines predict_satisfaction; the check below re-verifies it.\n", "def predict_satisfaction(gdp, kind=\"model\"):\n", " if kind == \"model\":\n", " result = slope * gdp + intercept\n", " elif kind == \"instance\":\n", " result = knn.predict(np.array([[gdp]]))[0]\n", " else:\n", " raise ValueError(f\"kind must be 'model' or 'instance', got {kind!r}\")\n", " return float(result)\n", "\n", "check(\"1.1 predict (model + instance)\", _ex11, required=True)\n", "print(f\"Cyprus (GDP 26,240): line says {predict_satisfaction(26240, 'model'):.2f}, \"\n", " f\"3-NN says {predict_satisfaction(26240, 'instance'):.2f}\")" ] }, { "cell_type": "markdown", "id": "cd88cb50", "metadata": {}, "source": [ "> **Key takeaways**\n", "> - Mitchell's `T`/`P`/`E` are three named things; if you cannot point at all three, the model claim is incomplete.\n", "> - Always beat the dumb baseline before celebrating; here it is \"predict the mean\".\n", "> - Instance-based models *are* the data (k-NN); model-based models compress it into parameters (a line). Same data, two representations.\n", "> - Every hand-rolled fit gets checked against a library so the notebook cannot quietly lie.\n" ] }, { "cell_type": "markdown", "id": "65efee05", "metadata": {}, "source": [ "## Part 2 — The line that lies\n", "\n", "> **Objectives.** Reproduce Géron's sampling-bias reveal. Fit a line to a hand-picked middle slice of countries, watch it look excellent, then add back the countries that were dropped and watch the same line become wrong. The lesson is that a model is only as honest as the sample it was fit on.\n", "\n", "Géron's original chapter quietly fits its line to a *subset* of countries (a mid-income band) and gets a clean trend. The trick is the subset. We do the same thing on purpose, name it, and then undo it.\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "7b26e342", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.813724Z", "iopub.status.busy": "2026-06-10T18:49:12.813619Z", "iopub.status.idle": "2026-06-10T18:49:12.816865Z", "shell.execute_reply": "2026-06-10T18:49:12.816585Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "slice: 19 countries in [18,000, 55,000] dropped: 17\n" ] } ], "source": [ "# The hand-picked slice: middle-income countries only (a common, innocent-looking\n", "# filter). We drop the very poor and the very rich, exactly the tails that bend the curve.\n", "LOW, HIGH = 18000, 55000 # USD bounds chosen to carve out a clean-looking middle band\n", "slice_mask = (df.gdp_per_capita_usd >= LOW) & (df.gdp_per_capita_usd <= HIGH)\n", "df_slice = df[slice_mask]\n", "df_rest = df[~slice_mask]\n", "print(f\"slice: {len(df_slice)} countries in [{LOW:,}, {HIGH:,}] dropped: {len(df_rest)}\")" ] }, { "cell_type": "code", "execution_count": 11, "id": "08873c2f", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.817839Z", "iopub.status.busy": "2026-06-10T18:49:12.817763Z", "iopub.status.idle": "2026-06-10T18:49:12.821215Z", "shell.execute_reply": "2026-06-10T18:49:12.820920Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "slice-only line MAE on the slice: 0.246\n", "slice-only slope: 4.579e-05 (a clean, confident upward trend)\n" ] } ], "source": [ "Xs = df_slice[[\"gdp_per_capita_usd\"]].to_numpy(dtype=float)\n", "ys = df_slice[\"life_satisfaction\"].to_numpy(dtype=float)\n", "line_slice = LinearRegression().fit(Xs, ys)\n", "print(f\"slice-only line MAE on the slice: {P(ys, line_slice.predict(Xs)):.3f}\")\n", "print(f\"slice-only slope: {line_slice.coef_[0]:.3e} (a clean, confident upward trend)\")" ] }, { "cell_type": "markdown", "id": "3a638994", "metadata": {}, "source": [ "> **Predict:** the slice-only line has a low error and a tidy positive slope. Before running the next cell, predict its error on the countries we dropped.
AnswerMuch worse. The dropped tails are exactly where a straight line is most wrong: poor countries sit above the extrapolated line, the richest sit below it. The next cell measures it.
\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "679c97dc", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.822022Z", "iopub.status.busy": "2026-06-10T18:49:12.821946Z", "iopub.status.idle": "2026-06-10T18:49:12.950121Z", "shell.execute_reply": "2026-06-10T18:49:12.949815Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "slice-only line MAE on the DROPPED countries: 0.805\n" ] } ], "source": [ "# viz: the slice fit, then the dropped countries dropped back in\n", "gdp_grid = np.linspace(df.gdp_per_capita_usd.min(), df.gdp_per_capita_usd.max(), 200).reshape(-1, 1)\n", "fig, ax = plt.subplots(1, 2, figsize=(11, 4))\n", "ax[0].scatter(Xs[:, 0], ys, color=\"#1E40FF\", label=\"slice (fit on these)\")\n", "ax[0].plot(gdp_grid, line_slice.predict(gdp_grid), color=\"#FF6A00\", label=\"slice-only line\")\n", "ax[0].set_title(\"What you see if you only keep the middle\"); ax[0].legend()\n", "\n", "ax[1].scatter(Xs[:, 0], ys, color=\"#1E40FF\", label=\"slice\")\n", "ax[1].scatter(df_rest.gdp_per_capita_usd, df_rest.life_satisfaction,\n", " color=\"#C81E1E\", marker=\"x\", s=60, label=\"dropped countries\")\n", "ax[1].plot(gdp_grid, line_slice.predict(gdp_grid), color=\"#FF6A00\", label=\"same line\")\n", "ax[1].set_title(\"What the dropped countries do to it\"); ax[1].legend()\n", "for a in ax:\n", " a.set_xlabel(\"GDP per capita (USD)\"); a.set_ylabel(\"life satisfaction\")\n", "plt.tight_layout(); plt.show()\n", "\n", "mae_rest = P(df_rest.life_satisfaction, line_slice.predict(df_rest[[\"gdp_per_capita_usd\"]]))\n", "print(f\"slice-only line MAE on the DROPPED countries: {mae_rest:.3f}\")" ] }, { "cell_type": "markdown", "id": "9c56e58b", "metadata": {}, "source": [ "> **Interpretation.** The line that scored well on the slice is far worse on the countries it never saw. Nothing about the line changed; what changed is that we stopped hiding the inconvenient data. This is sampling bias: a conclusion that holds for the sample and not the population. The fix is never a fancier model. It is a representative sample.\n" ] }, { "cell_type": "markdown", "id": "ce5793ad", "metadata": {}, "source": [ "### Exercise 2.1 — Refit on everyone and measure the honesty gap\n", "`Difficulty 2/5 · ~12 min`\n", "\n", "Fit a fresh line on *all* the countries, and write `honesty_gap()` returning a dict with three errors, all measured by `P`:\n", "`{\"slice_line_on_slice\", \"slice_line_on_all\", \"full_line_on_all\"}`.\n", "The first is the flattering number; the second is the same line judged on the full population; the third is an honest model fit on a representative sample. You should see the gap close.\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "43ed9b75", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.951509Z", "iopub.status.busy": "2026-06-10T18:49:12.951432Z", "iopub.status.idle": "2026-06-10T18:49:12.955146Z", "shell.execute_reply": "2026-06-10T18:49:12.954874Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] 2.1 honesty gap: not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def honesty_gap():\n", " \"\"\"Return the three MAEs that expose sampling bias. Reuse line_slice, Xs, ys,\n", " X, y from above; fit one new line on all of (X, y).\"\"\"\n", " # TODO 1: fit a LinearRegression on ALL the data (X, y) -> full_line\n", " full_line = None\n", " # TODO 2: slice line judged on the slice it was fit on (the flattering number)\n", " slice_on_slice = None\n", " # TODO 3: slice line judged on EVERY country (use predict on X)\n", " slice_on_all = None\n", " # TODO 4: full line judged on every country\n", " full_on_all = None\n", " attempted(full_line, slice_on_slice, slice_on_all, full_on_all)\n", " return {\"slice_line_on_slice\": slice_on_slice,\n", " \"slice_line_on_all\": slice_on_all,\n", " \"full_line_on_all\": full_on_all}\n", "\n", "def _ex21():\n", " g = honesty_gap()\n", " assert g[\"slice_line_on_slice\"] < g[\"slice_line_on_all\"], \\\n", " \"the slice line MUST look better on its own slice than on everyone; that gap is the bias\"\n", " assert g[\"full_line_on_all\"] < g[\"slice_line_on_all\"], \\\n", " \"a line fit on everyone should beat the slice line judged on everyone\"\n", "\n", "check(\"2.1 honesty gap\", _ex21)" ] }, { "cell_type": "markdown", "id": "d1f0e364", "metadata": {}, "source": [ "
Hint 1 (conceptual)You already have `line_slice`. The only new fit is `LinearRegression().fit(X, y)`. Then call `.predict` on the right inputs and pass the results through `P`.
\n", "\n", "
Hint 2 (pseudocode)\n", "\n", "```python\n", "full_line = LinearRegression().fit(X, y)\n", "slice_on_slice = P(ys, line_slice.predict(Xs))\n", "slice_on_all = P(y, line_slice.predict(X))\n", "full_on_all = P(y, full_line.predict(X))\n", "```\n", "
\n", "\n", "
Help — both numbers came out equalYou probably scored `line_slice` on `X` twice. The flattering number scores it on `Xs`/`ys` (the slice); the honest one scores it on `X`/`y` (everyone).
\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "0a2ff6cf", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.955975Z", "iopub.status.busy": "2026-06-10T18:49:12.955903Z", "iopub.status.idle": "2026-06-10T18:49:12.959863Z", "shell.execute_reply": "2026-06-10T18:49:12.959404Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] 2.1 honesty gap\n", " slice_line_on_slice MAE 0.246\n", " slice_line_on_all MAE 0.509\n", " full_line_on_all MAE 0.429\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines honesty_gap; the check below re-verifies it.\n", "def honesty_gap():\n", " full_line = LinearRegression().fit(X, y)\n", " slice_on_slice = P(ys, line_slice.predict(Xs))\n", " slice_on_all = P(y, line_slice.predict(X))\n", " full_on_all = P(y, full_line.predict(X))\n", " return {\"slice_line_on_slice\": slice_on_slice,\n", " \"slice_line_on_all\": slice_on_all,\n", " \"full_line_on_all\": full_on_all}\n", "\n", "check(\"2.1 honesty gap\", _ex21, required=True)\n", "for k, v in honesty_gap().items():\n", " print(f\" {k:22} MAE {v:.3f}\")" ] }, { "cell_type": "markdown", "id": "399701ec", "metadata": {}, "source": [ "> **Key takeaways**\n", "> - A low training error on a sample you chose proves nothing about the population.\n", "> - Sampling bias is not a modelling bug; it is a data-collection bug, and no model fixes it.\n", "> - The honest comparison always scores on data the model did not select or see.\n" ] }, { "cell_type": "markdown", "id": "865a1240", "metadata": {}, "source": [ "## Part 3 — Overfitting, watched live\n", "\n", "> **Objectives.** Hold the sample fixed and honest this time, and vary model *capacity* instead. Fit polynomials of increasing degree, watch training error fall to zero while held-out error turns around, and read the bias-variance U-curve off a plot. This is the single most important picture in classical ML.\n", "\n", "Same data, fair split. The only knob we turn is polynomial degree, which is model capacity. The draft's decomposition:\n", "\n", "$$\\mathbb{E}[(y-\\hat f(x))^2] = \\underbrace{(\\mathbb{E}[\\hat f(x)]-f(x))^2}_{\\text{bias}^2} + \\underbrace{\\mathrm{Var}(\\hat f(x))}_{\\text{variance}} + \\underbrace{\\sigma^2}_{\\text{noise}}$$\n", "\n", "Low degree = high bias (underfit). High degree = high variance (overfit). We are going to *see* the trade-off, not just name it.\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "a82cbb92", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.960782Z", "iopub.status.busy": "2026-06-10T18:49:12.960707Z", "iopub.status.idle": "2026-06-10T18:49:12.964586Z", "shell.execute_reply": "2026-06-10T18:49:12.964179Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train 23 countries · validation 13 countries\n" ] } ], "source": [ "from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n", "from sklearn.pipeline import make_pipeline\n", "\n", "# Honest split this time: train on some countries, validate on the rest.\n", "Xtr, Xva, ytr, yva = train_test_split(X, y, test_size=0.35, random_state=SEED)\n", "print(f\"train {Xtr.shape[0]} countries · validation {Xva.shape[0]} countries\")\n", "\n", "def poly_model(degree):\n", " # scale before raising to powers, or degree-10 GDP values overflow to garbage.\n", " return make_pipeline(StandardScaler(), PolynomialFeatures(degree), LinearRegression())" ] }, { "cell_type": "markdown", "id": "e90c1ff9", "metadata": {}, "source": [ "> **Note:** the `StandardScaler` in the pipeline is not decoration. GDP values are tens of thousands; raised to the 10th power without scaling they reach `1e48` and the fit dissolves into floating-point noise. Scaling first keeps the powers numerically sane. This is itself a small leakage trap, handled correctly in the next part.\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "dc3ddf0e", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.965382Z", "iopub.status.busy": "2026-06-10T18:49:12.965311Z", "iopub.status.idle": "2026-06-10T18:49:12.976940Z", "shell.execute_reply": "2026-06-10T18:49:12.976505Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "best degree by validation error: 2 (val MAE 0.418)\n" ] } ], "source": [ "# Fit every degree, record train and validation error. This is the U-curve data.\n", "degrees = range(1, 11)\n", "train_err, val_err = [], []\n", "for d in degrees:\n", " m = poly_model(d).fit(Xtr, ytr)\n", " train_err.append(P(ytr, m.predict(Xtr)))\n", " val_err.append(P(yva, m.predict(Xva)))\n", "train_err, val_err = np.array(train_err), np.array(val_err)\n", "best_degree = int(np.array(list(degrees))[np.argmin(val_err)])\n", "print(f\"best degree by validation error: {best_degree} (val MAE {val_err.min():.3f})\")" ] }, { "cell_type": "code", "execution_count": 17, "id": "1835e746", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:12.977871Z", "iopub.status.busy": "2026-06-10T18:49:12.977797Z", "iopub.status.idle": "2026-06-10T18:49:13.045185Z", "shell.execute_reply": "2026-06-10T18:49:13.044864Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# viz: the bias-variance U-curve, the picture this whole part exists for\n", "fig, ax = plt.subplots(figsize=(7, 4))\n", "ax.plot(list(degrees), train_err, \"o-\", color=\"#1E40FF\", label=\"train error\")\n", "ax.plot(list(degrees), val_err, \"s-\", color=\"#C81E1E\", label=\"validation error\")\n", "ax.axvline(best_degree, ls=\":\", color=\"#888\", label=f\"best degree = {best_degree}\")\n", "ax.set_xlabel(\"polynomial degree (model capacity)\"); ax.set_ylabel(\"MAE\")\n", "ax.set_title(\"Training error always falls; validation error turns around\")\n", "ax.legend(); plt.tight_layout(); plt.show()" ] }, { "cell_type": "markdown", "id": "8179b584", "metadata": {}, "source": [ "> **Interpretation.** Training error drifts slowly down as degree climbs (with only ~23 training countries even a degree-10 polynomial cannot bend through all of them, so it never reaches zero here). Validation error tells the real story: it falls, bottoms out around degree 2, then explodes by orders of magnitude as the high-degree fit swings wildly between and beyond the training points. The minimum of the red curve is the bias-variance sweet spot. Left of it is underfitting (high bias); right of it is overfitting (high variance, here a runaway one). The same picture appears for every model class in this curriculum, with \"degree\" replaced by depth, width, or training steps.\n", "\n", "> **Note:** in the classic textbook drawing, the overfit model drives *training* error to zero. On a dataset this small the giveaway is the opposite end: training error stays moderate while validation error blows up. Both are the same disease (capacity fitting noise), and the validation curve catches both.\n" ] }, { "cell_type": "markdown", "id": "4d2c03d3", "metadata": {}, "source": [ "### A deliberate failure: the model that memorised\n", "\n", "Let's stage the overfit on purpose and look at it, the way fastbook stages a bad learning rate and then fixes it. We fit the highest-degree model, confirm it nails the training countries, and then watch it produce nonsense between them.\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "a1594743", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.046260Z", "iopub.status.busy": "2026-06-10T18:49:13.046179Z", "iopub.status.idle": "2026-06-10T18:49:13.120750Z", "shell.execute_reply": "2026-06-10T18:49:13.120408Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "degree-10 TRAIN MAE: 0.3030 <- looks fine\n", "degree-10 VAL MAE: 2107.0992 <- the truth (orders of magnitude worse)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# BROKEN-ON-PURPOSE: maximum capacity, then judged on data it never saw.\n", "overfit = poly_model(10).fit(Xtr, ytr)\n", "print(f\"degree-10 TRAIN MAE: {P(ytr, overfit.predict(Xtr)):.4f} <- looks fine\")\n", "print(f\"degree-10 VAL MAE: {P(yva, overfit.predict(Xva)):.4f} <- the truth (orders of magnitude worse)\")\n", "\n", "# viz: the wiggle. A dense grid exposes what the model does between training points.\n", "grid = np.linspace(X.min(), X.max(), 300).reshape(-1, 1)\n", "fig, ax = plt.subplots(figsize=(7, 4))\n", "ax.scatter(Xtr[:, 0], ytr, color=\"#1E40FF\", label=\"train\")\n", "ax.scatter(Xva[:, 0], yva, color=\"#C81E1E\", marker=\"x\", s=60, label=\"validation\")\n", "ax.plot(grid, overfit.predict(grid), color=\"#FF6A00\", label=\"degree-10 fit\")\n", "ax.set_ylim(3, 9); ax.set_xlabel(\"GDP per capita (USD)\"); ax.set_ylabel(\"life satisfaction\")\n", "ax.set_title(\"Degree 10: tame near the training points, wild in between\"); ax.legend()\n", "plt.tight_layout(); plt.show()" ] }, { "cell_type": "markdown", "id": "12618a4d", "metadata": {}, "source": [ "> **Interpretation.** The fit hugs the training points and then swings violently in the gaps between them, which is where the validation countries live. (We clipped the y-axis to 3-9; the actual curve shoots far past the 0-10 satisfaction scale off-screen.) A respectable training error next to a blown-out validation error is the diagnosis. Now the fix: drop back to the degree the validation curve chose.\n" ] }, { "cell_type": "code", "execution_count": 19, "id": "be1f3cd9", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.121823Z", "iopub.status.busy": "2026-06-10T18:49:13.121741Z", "iopub.status.idle": "2026-06-10T18:49:13.125780Z", "shell.execute_reply": "2026-06-10T18:49:13.125431Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "degree-2 TRAIN MAE: 0.3495\n", "degree-2 VAL MAE: 0.4181 <- lower than degree-10's val error\n", "[ ok ] the validation-selected model generalises at least as well as the memoriser\n" ] } ], "source": [ "# THE FIX: use the validation-selected degree, not the most flexible one.\n", "fixed = poly_model(best_degree).fit(Xtr, ytr)\n", "print(f\"degree-{best_degree} TRAIN MAE: {P(ytr, fixed.predict(Xtr)):.4f}\")\n", "print(f\"degree-{best_degree} VAL MAE: {P(yva, fixed.predict(Xva)):.4f} <- lower than degree-10's val error\")\n", "assert P(yva, fixed.predict(Xva)) <= P(yva, overfit.predict(Xva)) + 1e-9, \\\n", " \"the validation-selected degree should not lose to degree 10 on validation, by construction\"\n", "print(\"[ ok ] the validation-selected model generalises at least as well as the memoriser\")" ] }, { "cell_type": "markdown", "id": "e373b0bf", "metadata": {}, "source": [ "### Exercise 3.1 — Write the diagnosis\n", "`Difficulty 2/5 · ~12 min`\n", "\n", "Turn the train/val gap into a verdict. Write `diagnose(train_mae, val_mae, tol=0.15)` returning one of the strings `\"underfit\"`, `\"overfit\"`, or `\"good\"`:\n", "- **overfit**: validation error exceeds training error by more than `tol`. The model fits the training data and fails off it. (On our data this gap is enormous; in the textbook version training error also collapses, but the *gap* is the reliable signal, so test it first.)\n", "- **underfit**: no large gap, but training error itself is high (above `3*tol`). The model is too simple to fit even the training data. (We use `3*tol`, not `tol`, because this curved, tiny dataset has an irreducible error around 0.33 satisfaction points; a sensible model lands there, not at zero.)\n", "- **good**: otherwise (low training error, validation close behind).\n", "\n", "Order matters: test the overfit gap first, then the underfit absolute level, then good. This is the rule you will apply to every loss curve from here on.\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "81716af1", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.126656Z", "iopub.status.busy": "2026-06-10T18:49:13.126581Z", "iopub.status.idle": "2026-06-10T18:49:13.130136Z", "shell.execute_reply": "2026-06-10T18:49:13.129810Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] 3.1 diagnose: not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def diagnose(train_mae, val_mae, tol=0.15):\n", " \"\"\"Classify a train/val error pair as 'overfit', 'underfit', or 'good'.\"\"\"\n", " # TODO 1: overfit first, validation exceeds training by more than tol\n", " # TODO 2: underfit next, no big gap but training error itself is high (> 3*tol)\n", " # TODO 3: otherwise good\n", " verdict = None\n", " attempted(verdict)\n", " return verdict\n", "\n", "def _ex31():\n", " assert diagnose(0.8, 0.85) == \"underfit\", \"both errors high -> underfit\"\n", " assert diagnose(0.05, 0.45) == \"overfit\", \"tiny train, big val gap -> overfit\"\n", " assert diagnose(0.12, 0.18) == \"good\", \"low train, val close behind -> good\"\n", " # apply it to the real curves we computed: degree 10 should read as overfit\n", " d10 = diagnose(P(ytr, overfit.predict(Xtr)), P(yva, overfit.predict(Xva)))\n", " assert d10 == \"overfit\", f\"degree-10 should diagnose as overfit, got {d10!r}\"\n", "\n", "check(\"3.1 diagnose\", _ex31)" ] }, { "cell_type": "markdown", "id": "f33d0dc3", "metadata": {}, "source": [ "
Hint 1 (conceptual)Order matters: test the overfit *gap* (`val - train > tol`) first. Only if there is no big gap do you ask whether training error is high (underfit). Otherwise it is good.
\n", "\n", "
Hint 2 (pseudocode)\n", "\n", "```python\n", "if val_mae - train_mae > tol:\n", " verdict = \"overfit\"\n", "elif train_mae > 3 * tol:\n", " verdict = \"underfit\"\n", "else:\n", " verdict = \"good\"\n", "```\n", "
\n", "\n", "
Help — the (0.8, 0.85) case reads as 'overfit'Both errors are high but close together: that is underfit, not overfit. The gap `0.85 - 0.8 = 0.05` is below `tol`, so the overfit branch should not fire. Check you are comparing `val - train` against `tol`, not against zero.
\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "31819c36", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.131224Z", "iopub.status.busy": "2026-06-10T18:49:13.131100Z", "iopub.status.idle": "2026-06-10T18:49:13.137467Z", "shell.execute_reply": "2026-06-10T18:49:13.137103Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] 3.1 diagnose\n", "degree 2: train 0.349 val 0.418 -> good\n", "degree 4: train 0.335 val 0.673 -> overfit\n", "degree 10: train 0.303 val 2107.099 -> overfit\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines diagnose; the check below re-verifies it.\n", "def diagnose(train_mae, val_mae, tol=0.15):\n", " if val_mae - train_mae > tol:\n", " return \"overfit\"\n", " if train_mae > 3 * tol:\n", " return \"underfit\"\n", " return \"good\"\n", "\n", "check(\"3.1 diagnose\", _ex31, required=True)\n", "for d in (best_degree, 4, 10):\n", " m = poly_model(d).fit(Xtr, ytr)\n", " tr, va = P(ytr, m.predict(Xtr)), P(yva, m.predict(Xva))\n", " print(f\"degree {d:2d}: train {tr:.3f} val {va:.3f} -> {diagnose(tr, va)}\")" ] }, { "cell_type": "markdown", "id": "b06e37ea", "metadata": {}, "source": [ "> **Key takeaways**\n", "> - Training error always drops with capacity; validation error is the one that tells the truth.\n", "> - The U-shaped validation curve is the bias-variance trade-off made visible; its minimum is the model you ship.\n", "> - A near-perfect training score on a small dataset is a red flag, not a result.\n", "> - \"underfit / overfit / good\" is a rule about the gap, and you now have it as code.\n" ] }, { "cell_type": "markdown", "id": "58ef62a2", "metadata": {}, "source": [ "## Part 4 — No labels, then a boundary\n", "\n", "> **Objectives.** Show the supervision axis on the same countries. First unsupervised: hide every label and let k-means find structure, then check whether the structure it found lines up with something real. Then supervised: define a \"happy\" label and learn a decision boundary you can draw as an image.\n", "\n", "The single biggest split between ML algorithms is what their training data looks like. Supervised learning sees `(x, y)` pairs. Unsupervised learning sees only `x` and has to invent the structure. We demonstrate both on the country data.\n" ] }, { "cell_type": "markdown", "id": "6b7d4696", "metadata": {}, "source": [ "### 4.1 Unsupervised: find groups with the labels hidden\n", "\n", "We give k-means two features (GDP and satisfaction), standardised, and *no* target. It returns a grouping. Whether that grouping means anything is a separate question we then test against an external fact (the rich-country flag), which the algorithm never saw.\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "556a3cf6", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.138266Z", "iopub.status.busy": "2026-06-10T18:49:13.138192Z", "iopub.status.idle": "2026-06-10T18:49:13.167706Z", "shell.execute_reply": "2026-06-10T18:49:13.167396Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cluster sizes: [20 16]\n", "inertia (within-cluster sum of squares): 22.90\n" ] } ], "source": [ "from sklearn.cluster import KMeans\n", "from sklearn.preprocessing import StandardScaler\n", "\n", "feat = df[[\"gdp_per_capita_usd\", \"life_satisfaction\"]].to_numpy(dtype=float)\n", "feat_s = StandardScaler().fit_transform(feat) # both axes to mean 0, std 1, so neither dominates\n", "# n_init=10: k-means is non-convex, so we restart 10 times and keep the best inertia.\n", "km = KMeans(n_clusters=2, n_init=10, random_state=SEED).fit(feat_s)\n", "labels = km.labels_\n", "print(f\"cluster sizes: {np.bincount(labels)}\")\n", "print(f\"inertia (within-cluster sum of squares): {km.inertia_:.2f}\")" ] }, { "cell_type": "markdown", "id": "ef79ad56", "metadata": {}, "source": [ "> **Caveat — the k-means convergence trap.** k-means alternates assign-then-recenter until labels stop changing. A naive implementation that seeds its \"previous labels\" to `np.zeros(n)` and breaks when current equals previous can exit on iteration one if the first assignment happens to be all-zeros, before any centroid moves. scikit-learn does not have this bug (it tracks centroid shift against a tolerance and caps `max_iter`), which is exactly why we use it here rather than hand-rolling the loop. When you do write k-means from scratch in Ch 08, the sentinel must be \"centroids moved less than `tol`\", never \"labels equal a zero array\".\n" ] }, { "cell_type": "code", "execution_count": 23, "id": "c7953ac7", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.168764Z", "iopub.status.busy": "2026-06-10T18:49:13.168682Z", "iopub.status.idle": "2026-06-10T18:49:13.239858Z", "shell.execute_reply": "2026-06-10T18:49:13.239485Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAArIAAAGGCAYAAACHemKmAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZZJJREFUeJzt3Xl4TNf/B/D3ZJJMQmRBVrIh9pCQyjd2bSyhammlVRq7KimqtNVWCbV2sa+thhZV1Fa1xVb7WrELIRIlEUK2ImFyfn/Mb6bGTGImJpkl79fzzMOce+bec++ZmXxycu75SIQQAkREREREZsbK2A0gIiIiIioOBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrKkZsKECZBIJLh3756xm2JRlNe1LLp58ybs7Oxw6NAhVVnfvn3h5+dXrP1JJBJER0cbqHXAjRs3IJFIsGzZMoPt09y0bt0a9evXf2E9fa6Vrn1s7Ou/fft2BAUFwc7ODhKJBJmZmUZpx8tQXsNvv/3W2E1R8fPzQ9++fY12/NatW6N169Y619Xl/f+ynjx5Am9vbyxYsKDEj1WWMJAlsgCrVq3CrFmzjN0MrSZOnIjQ0FA0a9bM2E0hUpORkYHIyEjY29tj/vz5+OWXX1C+fHljN6tQW7duxYQJE4zdDLN0+/ZtTJgwAfHx8UZrg42NDUaNGoXJkyfj8ePHRmuHpWEgS2QBTDWQvXv3LpYvX44hQ4YYuylkAL6+vnj06BHee+89YzfFIE6cOIGcnBxMmjQJAwYMQO/evWFjY2PsZhVq69atiImJMXYzzMLOnTuxc+dO1fPbt28jJibGqIEsAPTr1w/37t3DqlWrjNoOS8JAloi0KigoeOlRgxUrVsDa2hqdO3c2UKvoeQ8fPiy1Y0kkEtjZ2UEqlZbaMUtSeno6AMDZ2fmFdUvzOlPxKfvJ1tYWtra2Rm6NJmdnZ7Rr165MT2UyNAay9ELJycmoUaMG6tevjzt37hRZ18/PD6+//jr27duHkJAQ2NvbIzAwEPv27QMArF+/HoGBgbCzs0Pjxo1x+vRpjX1cvnwZb731FipWrAg7OzuEhIRg8+bNanXu37+P0aNHIzAwEA4ODnB0dERERATOnDmjVm/fvn2QSCRYs2YNJk+ejKpVq8LOzg6vvfYaEhMT1epevXoVb775Jjw8PGBnZ4eqVavinXfeQVZW1guv0bFjx9CxY0e4uLigfPnyaNCgAWbPnl1o/aLmBUokErU/H+bk5GDkyJHw8/ODTCaDm5sb2rZti7///huAYn7Xn3/+ieTkZEgkEkgkErW5iXl5eRg/fjxq1KgBmUwGb29vfPLJJ8jLy9M4bnR0NFauXIl69epBJpNh+/btAIDVq1ejcePGqFChAhwdHREYGFjk+Slt3LgRoaGhcHBweGHdb7/9Fk2bNkWlSpVgb2+Pxo0bY926dYXWX7lyJWrVqqV6L+3fv1+jzq1bt9C/f3+4u7tDJpOhXr16+Omnn17YlrS0NPTr1w9Vq1aFTCaDp6cnunTpghs3bhT6ms2bN0MikeDs2bOqst9//x0SiQTdu3dXq1unTh28/fbbamUrVqxA48aNYW9vj4oVK+Kdd97BzZs31eoo5/KdOnUKLVu2RLly5fD5558D0L2fi3Lx4kW0adMG5cqVQ5UqVTBjxgy17YW9bzdu3Ij69evDzs4O9evXx4YNG7TuPzMzE3379oWTkxOcnZ3Rp0+fQuek6vI9sGzZMkgkEhw6dAijRo2Cq6srypcvj27duuHu3btFnmvr1q3Rp08fAMArr7wCiUSimtNZ1HVOT0/HgAED4O7uDjs7OzRs2BDLly/Xep2+/fZbzJ8/H9WqVUO5cuXQrl073Lx5E0IITJo0CVWrVoW9vT26dOmC+/fvF9nevn37Yv78+QCg+pxrm3e/ZMkSVK9eHTKZDK+88gpOnDhRrGtbGH0/p886e/YsWrVqBXt7e1StWhVff/01YmNjIZFIND5bCxYsUH0PeXl5YdiwYRrvlaL66dk5svv27cMrr7wCQDEiqrx2z7+PX/T+f/bnSUxMDKpUqYIKFSrgrbfeQlZWFvLy8jBy5Ei4ubnBwcEB/fr10/r5a9u2LQ4ePPjCPifdWBu7AWTarl27hldffRUVK1ZEXFwcKleu/MLXJCYm4t1338X777+P3r1749tvv0Xnzp2xaNEifP755xg6dCgAYOrUqYiMjERCQgKsrBS/U124cAHNmjVDlSpV8Nlnn6F8+fJYs2YNunbtit9//x3dunUDAFy/fh0bN25Ejx494O/vjzt37mDx4sVo1aoVLl68CC8vL7U2TZs2DVZWVhg9ejSysrIwY8YM9OrVC8eOHQMA5Ofno3379sjLy8OHH34IDw8P3Lp1C1u2bEFmZiacnJwKPd+4uDi8/vrr8PT0xIgRI+Dh4YFLly5hy5YtGDFiRLGu+7OGDBmCdevWITo6GnXr1kVGRgYOHjyIS5cuoVGjRvjiiy+QlZWFf/75BzNnzgQAVeBYUFCAN954AwcPHsTgwYNRp04dnDt3DjNnzsSVK1ewceNGtWPt2bMHa9asQXR0NCpXrgw/Pz/ExcWhZ8+eeO211zB9+nQAwKVLl3Do0KEiz+/Jkyc4ceIEPvjgA53Oc/bs2XjjjTfQq1cv5OfnY/Xq1ejRowe2bNmCTp06qdX966+/8Ntvv2H48OGQyWRYsGABOnTogOPHj6tu2rhz5w7+97//qQJ0V1dXbNu2DQMGDEB2djZGjhxZaFvefPNNXLhwAR9++CH8/PyQnp6OuLg4pKSkFHoDU/PmzSGRSLB//340aNAAAHDgwAFYWVnh4MGDqnp3797F5cuX1W5Ymzx5MsaNG4fIyEgMHDgQd+/exdy5c9GyZUucPn1abcQwIyMDEREReOedd9C7d2+4u7vr3c/aPHjwAB06dED37t0RGRmJdevW4dNPP0VgYCAiIiIKfd3OnTvx5ptvom7dupg6dSoyMjJUvwQ8SwiBLl264ODBgxgyZAjq1KmDDRs2qILJZ+n6PaD04YcfwsXFBePHj8eNGzcwa9YsREdH47fffiu03V988QVq1aqFJUuWYOLEifD390f16tWLvM6PHj1C69atkZiYiOjoaPj7+2Pt2rXo27cvMjMzNT4PK1euRH5+Pj788EPcv38fM2bMQGRkJF599VXs27cPn376KRITEzF37lyMHj26yF+y3n//fdy+fRtxcXH45ZdftNZZtWoVcnJy8P7770MikWDGjBno3r07rl+/rpoyoe+1fZ4+n9Nn3bp1C23atIFEIsHYsWNRvnx5/Pjjj5DJZBp1J0yYgJiYGISHh+ODDz5AQkICFi5ciBMnTuDQoUNq0z+09dPz6tSpg4kTJ+Krr77C4MGD0aJFCwBA06ZNVXX0ef9PnToV9vb2+Oyzz1T9Z2NjAysrKzx48AATJkzA0aNHsWzZMvj7++Orr75Se33jxo0hhMDhw4fx+uuvF3m9SQeC6Bnjx48XAMTdu3fFpUuXhJeXl3jllVfE/fv3dXq9r6+vACAOHz6sKtuxY4cAIOzt7UVycrKqfPHixQKA2Lt3r6rstddeE4GBgeLx48eqsoKCAtG0aVMREBCgKnv8+LGQy+Vqx05KShIymUxMnDhRVbZ3714BQNSpU0fk5eWpymfPni0AiHPnzgkhhDh9+rQAINauXavTeSo9ffpU+Pv7C19fX/HgwQO1bQUFBar/K6/rs20FIGJjYzX2CUCMHz9e9dzJyUkMGzasyHZ06tRJ+Pr6apT/8ssvwsrKShw4cECtfNGiRQKAOHTokNpxraysxIULF9TqjhgxQjg6OoqnT58W2YbnJSYmCgBi7ty5Gtv69Omj0d6HDx+qPc/Pzxf169cXr776qlo5AAFAnDx5UlWWnJws7OzsRLdu3VRlAwYMEJ6enuLevXtqr3/nnXeEk5OT6njP98WDBw8EAPHNN9/odb5CCFGvXj0RGRmpet6oUSPRo0cPAUBcunRJCCHE+vXrBQBx5swZIYQQN27cEFKpVEyePFltX+fOnRPW1tZq5a1atRIAxKJFi9Tq6tPP2ij3+/PPP6vK8vLyhIeHh3jzzTdVZdret0FBQcLT01NkZmaqynbu3CkAqPXxxo0bBQAxY8YMVdnTp09FixYtNPap6/dAbGysACDCw8PVPm8fffSRkEqlam3SRvn6EydOaL0ez1/nWbNmCQBixYoVqrL8/HwRFhYmHBwcRHZ2ttp1cnV1VWvD2LFjBQDRsGFD8eTJE1V5z549ha2trdr5ajNs2DC17xEl5fEqVaqk9l29adMmAUD88ccfqjJdr21hdP2c+vr6ij59+qief/jhh0IikYjTp0+ryjIyMkTFihUFAJGUlCSEECI9PV3Y2tqKdu3aqX3Hz5s3TwAQP/30k6qssH5SbmvVqpXq+YkTJwr9ztX1/a/8eVK/fn2Rn5+vKu/Zs6eQSCQiIiJCbb9hYWFav5dv374tAIjp06drbCP9cWoBaXX+/Hm0atUKfn5+2LVrF1xcXHR+bd26dREWFqZ6HhoaCgB49dVX4ePjo1F+/fp1AIrpAnv27EFkZCRycnJw79493Lt3DxkZGWjfvj2uXr2KW7duAQBkMplqFFculyMjIwMODg6oVauW6k/uz+rXr5/afCnlb+TKYytHXHfs2KHXXLjTp08jKSkJI0eO1JhnZ6jltpydnXHs2DHcvn1b79euXbsWderUQe3atVXX8969e3j11VcBAHv37lWr36pVK9StW1fj+P/++y/i4uL0OnZGRgYA6Pzesbe3V/3/wYMHyMrKQosWLbT2Z1hYGBo3bqx67uPjgy5dumDHjh2Qy+UQQuD3339H586dIYRQO/f27dsjKytL636V7bC1tcW+ffvw4MEDfU4ZLVq0wIEDBwAopoScOXMGgwcPRuXKlVXlBw4cgLOzs2rkeP369SgoKEBkZKRaOz08PBAQEKDRRzKZDP369VMr07eftXFwcEDv3r1Vz21tbdGkSRPVZ0Sb1NRUxMfHo0+fPmp/tWjbtq3G+2jr1q2wtrZWG6GXSqX48MMP1erp8z2gNHjwYLXPW4sWLSCXy5GcnPzC8y6Mtuu8detWeHh4oGfPnqoyGxsbDB8+HLm5ufjrr7/U6vfo0UPtuii/83r37g1ra2u18vz8fI3z0tfbb7+t9nl7/nuuONf2efp8Tp+1fft2hIWFISgoSFVWsWJF9OrVS63erl27kJ+fj5EjR6q+4wFg0KBBcHR0xJ9//qlWX1s/FYc+7/+oqCi1UeHQ0FAIIdC/f3+1eqGhobh58yaePn2qVq7sIy5zaRicWkBade7cGe7u7tixY4fG/Mbc3Fzk5uaqnkulUri6uqqePxusAv8Fid7e3lrLlcFCYmIihBAYN24cxo0bp7Vd6enpqFKlCgoKCjB79mwsWLAASUlJkMvlqjqVKlXSeN3zbVJ+kSiP7e/vj1GjRuH777/HypUr0aJFC7zxxhvo3bt3kdMKrl27BgAlugbhjBkz0KdPH3h7e6Nx48bo2LEjoqKiUK1atRe+9urVq7h06ZJa/zxLebOLkr+/v0adoUOHYs2aNYiIiECVKlXQrl07REZGokOHDjq1XwihU70tW7bg66+/Rnx8vNq8Mm2/EAQEBGiU1axZEw8fPsTdu3dhZWWFzMxMLFmyBEuWLNF6vOfPXUkmk2H69On4+OOP4e7ujv/97394/fXXERUVBQ8PjyLPoUWLFli0aBESExNx7do1SCQShIWFqQLcQYMG4cCBA2jWrJnqh/TVq1chhNB6TgA07qKvUqWKxk0s+vazNlWrVtW41i4uLmpzfp+nDBS1tf35XyqTk5Ph6emp8X1Sq1Yttef6fA8ovejzXRzarnNycjICAgLUAixA8adr5fZnFfe7sLhedB2Kc22fp8/n9FnJyclqAxxKNWrU0KgHaL4vbG1tUa1aNY1rrK2fikOf978+/VpQUICsrCy1n0vK78Syura4oTGQJa3efPNNLF++HCtXrsT777+vtu3bb79VWwLG19dXbaJ+YXc0F1au/FAXFBQAAEaPHo327dtrrav80psyZQrGjRuH/v37Y9KkSahYsSKsrKwwcuRI1X70OTYAfPfdd+jbty82bdqEnTt3Yvjw4Zg6dSqOHj2qMd/vZRX2BfZsQK4UGRmJFi1aYMOGDdi5cye++eYbTJ8+HevXry9y7iKguKaBgYH4/vvvtW5//ov32dEWJTc3N8THx2PHjh3Ytm0btm3bhtjYWERFRWnc5PIs5Re3Lj+cDxw4gDfeeAMtW7bEggUL4OnpCRsbG8TGxhZrmRrle6B3795a52ACUM1j1WbkyJHo3LkzNm7ciB07dmDcuHGYOnUq9uzZg+Dg4EJf17x5cwDA/v37cf36dTRq1Ajly5dHixYtMGfOHOTm5uL06dOYPHmyWlslEgm2bdum9X36fOCnrY/07WdtdPmMlAZ9vgeUSqLt2q6zvor7XWjo4xXnO1YbQ39ODcEQ/QTo1ycv26/K70Rd7jmhF2MgS1p98803sLa2xtChQ1GhQgW8++67qm1RUVGqH9iA4b5IlCOMNjY2CA8PL7LuunXr0KZNGyxdulStPDMz86W+HAIDAxEYGIgvv/wShw8fRrNmzbBo0SJ8/fXXWusrbw45f/78C9v8LOVIyfN34Rb2p1BPT08MHToUQ4cORXp6Oho1aoTJkyerAtnCAuPq1avjzJkzeO21117qt39bW1t07twZnTt3RkFBAYYOHYrFixdj3Lhxhf7g8/Hxgb29PZKSkl64/99//x12dnbYsWOH2s0fsbGxWutfvXpVo+zKlSsoV66calSyQoUKkMvlevXLs6pXr46PP/4YH3/8Ma5evYqgoCB89913WLFiRaGv8fHxgY+PDw4cOIDr16+r/rTbsmVLjBo1CmvXroVcLkfLli3VjiOEgL+/P2rWrFnsthqin/Xl6+sLQHt/JCQkaNTdvXs3cnNz1YLz5+vp8z1Q2nx9fXH27FkUFBSojcpevnxZtb0kvWzfvuy11fdz+ixfX1+NlWIAaJQpr2FCQoLaX53y8/ORlJRU7PeEKY1+Kr8TlSP59HI4R5a0kkgkWLJkCd566y306dNHbWmWatWqITw8XPUwVMYmNzc3tG7dGosXL0ZqaqrG9meX05FKpRq/5a5du7bYc8yys7M15jEFBgbCysqqyOWLGjVqBH9/f8yaNUsjKC1qdMXR0RGVK1fWWDLq+dSFcrlcY/kvNzc3eHl5qbWrfPnyWpcJi4yMxK1bt/DDDz9obHv06BH+/fffQtuopJzrqmRlZaUazSzq2tjY2CAkJAQnT5584TGkUikkEonaiPSNGzcKvdv+yJEjan+2vnnzJjZt2oR27dpBKpVCKpXizTffxO+//47z589rvL6opZkePnyosX5u9erVUaFCBZ2WsmrRogX27NmD48ePqwLZoKAgVKhQAdOmTVMtWaTUvXt3SKVSxMTEaLxnhBAa118bQ/RzcXh6eiIoKAjLly9Xe//FxcXh4sWLanU7duyIp0+fYuHChaoyuVyOuXPnqtXT53ugtHXs2BFpaWlqqyE8ffoUc+fOhYODA1q1alWix1dmHStuGt2Xvbb6fk6f1b59exw5ckQtIcH9+/excuVKtXrh4eGwtbXFnDlz1D4PS5cuRVZWVpErIxTlZa+dIZ06dUo17YheHkdkqVBWVlZYsWIFunbtisjISGzdulV180hJmT9/Ppo3b47AwEAMGjQI1apVw507d3DkyBH8888/qnViX3/9dUycOBH9+vVD06ZNce7cOaxcuVKneaPa7NmzB9HR0ejRowdq1qyJp0+f4pdfflEFRIWxsrLCwoUL0blzZwQFBaFfv37w9PTE5cuXceHCBezYsaPQ1w4cOBDTpk3DwIEDERISgv379+PKlStqdXJyclC1alW89dZbaNiwIRwcHLBr1y6cOHEC3333nape48aN8dtvv2HUqFF45ZVX4ODggM6dO+O9997DmjVrMGTIEOzduxfNmjWDXC7H5cuXsWbNGuzYsQMhISFFXpuBAwfi/v37ePXVV1G1alUkJydj7ty5CAoKeuGIQpcuXfDFF18gOzsbjo6Ohdbr1KkTvv/+e3To0AHvvvsu0tPTMX/+fNSoUUPrHLX69eujffv2astvAVCb8jJt2jTs3bsXoaGhGDRoEOrWrYv79+/j77//xq5duwpdw/HKlSt47bXXEBkZibp168La2hobNmzAnTt38M477xR5voAikF25ciUkEonqLxdSqRRNmzbFjh070Lp1a7U5fdWrV8fXX3+NsWPH4saNG+jatSsqVKiApKQkbNiwAYMHD8bo0aOLPKYh+rm4pk6dik6dOqF58+bo378/7t+/j7lz56JevXpqc+k7d+6MZs2a4bPPPsONGzdQt25drF+/XusvYLp+D5S2wYMHY/Hixejbty9OnToFPz8/rFu3DocOHcKsWbNQoUKFEj2+8heg4cOHo3379pBKpTq9J5/1MtdW38/psz755BOsWLECbdu2xYcffqhafsvHxwf3799XjZi6urpi7NixiImJQYcOHfDGG28gISEBCxYswCuvvKJ2Q5Y+qlevDmdnZyxatAgVKlRA+fLlERoaqvW+gJIWFxeHZs2aab2fg4qhFFdIIDPw7PJbSg8fPhStWrUSDg4O4ujRo0W+3tfXV3Tq1EmjHIDGElLKJWOeX+bo2rVrIioqSnh4eAgbGxtRpUoV8frrr4t169ap6jx+/Fh8/PHHwtPTU9jb24tmzZqJI0eOaCy5olwu5flltZ5fRuj69euif//+onr16sLOzk5UrFhRtGnTRuzatavI81U6ePCgaNu2rahQoYIoX768aNCggdqyU88vvyWE4roOGDBAODk5iQoVKojIyEiRnp6utvxWXl6eGDNmjGjYsKFq3w0bNhQLFixQ21dubq549913hbOzs8ayR/n5+WL69OmiXr16QiaTCRcXF9G4cWMRExMjsrKyVPW09ZEQQqxbt060a9dOuLm5CVtbW+Hj4yPef/99kZqa+sLrcufOHWFtbS1++eUXtXJty28tXbpUBAQECJlMJmrXri1iY2O1XjdlO1esWKGqHxwcrLaM27PHHzZsmPD29hY2NjbCw8NDvPbaa2LJkiWqOs+/F+7duyeGDRsmateuLcqXLy+cnJxEaGioWLNmzQvPVwghLly4oFry7Vlff/21ACDGjRun9XW///67aN68uShfvrwoX768qF27thg2bJhISEhQ1WnVqpWoV6+e1tfr2s/aFLbf5/upsGXjfv/9d1GnTh0hk8lE3bp1xfr167X2cUZGhnjvvfeEo6OjcHJyEu+9955q6bvn96nL90Bhy2cpP/fa3hPPKmr5rcKu8507d0S/fv1E5cqVha2trQgMDNRoe2HfbYV9HxXWjuc9ffpUfPjhh8LV1VVIJBLVZ6Ow4wmhuZyfELpd28Lo+jl9fvktIRTLHLZo0ULIZDJRtWpVMXXqVDFnzhwBQKSlpanVnTdvnqhdu7awsbER7u7u4oMPPtBY4rCofnr+Z4EQiuXI6tatK6ytrdXec7q+//XtP20/TzMzM4Wtra348ccftbab9CcRopRn8hNRmTJgwABcuXJFtfwUEZHSyJEjsXjxYuTm5lpM6uOizJo1CzNmzMC1a9cMdn9JWcdAlohKVEpKCmrWrIndu3cbbD41EZmfR48eqQVvGRkZqFmzJho1aqT3OtXm6MmTJ6hevTo+++wzVYZLenkMZImIiKjEBQUFoXXr1qhTpw7u3LmDpUuX4vbt29i9e7faSh5E+uDNXkRERFTiOnbsiHXr1mHJkiWQSCRo1KgRli5dyiCWXgpHZImIiIjILHEdWSIiIiIySwxkiYiIiMgslbk5sgUFBbh9+zYqVKhgUinriIiIiEiR1TAnJwdeXl5q6aC1KXOB7O3bt+Ht7W3sZhARERFREW7evImqVasWWafMBbLKFII3b94sMmUmEREREZW+7OxseHt765T2ucwFssrpBI6OjgxkiYiIiEyULlNAebMXEREREZklBrJEREREZJYYyBIRERGRWSpzc2SJiIjI8hQUFCA/P9/YzSAd2NjYQCqVGmRfDGSJiIjIrOXn5yMpKQkFBQXGbgrpyNnZGR4eHi+9pj8DWSIiIjJbQgikpqZCKpXC29v7hQvok3EJIfDw4UOkp6cDADw9PV9qfwxkiahsK5ADiQeA7FTA0ROo0QKwMsyfvAzC1NtXUsrqeZPenj59iocPH8LLywvlypUzdnNIB/b29gCA9PR0uLm5vdQ0AwayRFR2xa8H1o4AMv/5r8y5KtBjNhDU3XjtUjL19pWUsnreVCxyuRwAYGtra+SWkD6Uv3Q8efLkpQJZjr8TUdkUvx744S31YAkAMm8pyuPXG6ddSqbevpJSVs+bXtrLzrWk0mWo/mIgS0RlT4FcMeIHoWXj/5etG6moZwym3r6SUlbPm4iKjYEsEZU9iQc0R/zUCODBTUU9YzD19pWUsnreRM+5ceMGJBIJ4uPjjd0Uk8dAlojKnuxUw9YzNFNvX0kpq+dNVMKWLVsGZ2fnEj1GSkoKOnXqhHLlysHNzQ1jxozB06dPS/SYAG/2IqKyyFHH5V50rWdopt6+klJWz5tMglwOHD8HpGcAbpWAJoGAgdbstxhyuRwSiURjiTO5XI5OnTrBw8MDhw8fRmpqKqKiomBjY4MpU6aUaJs4IktEZU+NFoq74FHYzQYSwMVbUc8YTL19JaWsnjcZ3bb9QLOewDsfAcO/VvzbrKeivKQUFBRgxowZqFGjBmQyGXx8fDB58mStdbWNqG7cuFHthqkzZ86gTZs2qFChAhwdHdG4cWOcPHkS+/btQ79+/ZCVlQWJRAKJRIIJEyYAAPLy8jB69GhUqVIF5cuXR2hoKPbt26dx3M2bN6Nu3bqQyWRISUnRaN/OnTtx8eJFrFixAkFBQYiIiMCkSZMwf/78Es+2xkCWiMoeK6liKScAmkHT/z9/a5bx1i019faVlLJ63mRU2/YDH4wHUu+ql6fdVZSXVDA7duxYTJs2DePGjcPFixexatUquLu7F3t/vXr1QtWqVXHixAmcOnUKn332GWxsbNC0aVPMmjULjo6OSE1NRWpqKkaPHg0AiI6OxpEjR7B69WqcPXsWPXr0QIcOHXD16lXVfh8+fIjp06fjxx9/xIULF+Dm5qZx7CNHjiAwMFCt/e3bt0d2djYuXLhQ7HPSBacWEFHZFNQdGLROc71Sl6qKYMnY65WaevtKSlk9bzIKuRyImVf4OhkSKLa3a2bYaQY5OTmYPXs25s2bhz59+gAAqlevjubNmxd7nykpKRgzZgxq164NAAgICFBtc3JygkQigYeHh1r92NhYpKSkwMvLCwAwevRobN++HbGxsaopAU+ePMGCBQvQsGHDQo+dlpamEYQrn6elpRX7nHRh1EDWz88PycnJGuVDhw7F/PnzNcqXLVuGfv36qZXJZDI8fvy4xNpIRBYsqDvQoIvpZpAy9faVlLJ63obAjGh6OX5OcyT2WQKK7cfPAWFBhjvupUuXkJeXh9dee81g+xw1ahQGDhyIX375BeHh4ejRoweqV69eaP1z585BLpejZs2aauV5eXmoVKmS6rmtrS0aNGhgsHYamlED2RMnTqgycgDA+fPn0bZtW/To0aPQ1zg6OiIhIUH1nAsgE9FLsZICNVsbuxWFM/X2lZSyet4vgxnR9JaeYdh6ulKmaNWVlZUVhFAfN37y5Ina8wkTJuDdd9/Fn3/+iW3btmH8+PFYvXo1unXrpnWfubm5kEqlOHXqlEZmLQcHB7W2vijW8vDwwPHjx9XK7ty5o9pWkow6R9bV1RUeHh6qx5YtW1C9enW0atWq0Ncoh8aVj5eZT0JERGQRmBGtWNwqvbiOPvV0FRAQAHt7e+zevVun+q6ursjJycG///6rKtO2xmzNmjXx0UcfYefOnejevTtiY2MBKEZVnx04BIDg4GDI5XKkp6ejRo0aag99g8+wsDCcO3cO6enpqrK4uDg4Ojqibt26eu1LXyZzs1d+fj5WrFiB/v37Fxn55+bmwtfXF97e3ujSpUuJTyImIiIyacyIVmxNAgFP1yLXyYCnq6KeIdnZ2eHTTz/FJ598gp9//hnXrl3D0aNHsXTpUq31Q0NDUa5cOXz++ee4du0aVq1ahWXLlqm2P3r0CNHR0di3bx+Sk5Nx6NAhnDhxAnXq1AGgmMqZm5uL3bt34969e3j48CFq1qyJXr16ISoqCuvXr0dSUhKOHz+OqVOn4s8//9TrfNq1a4e6devivffew5kzZ7Bjxw58+eWXGDZsGGQyWbGvky5MJpDduHEjMjMz0bdv30Lr1KpVCz/99BM2bdqEFStWoKCgAE2bNsU//xSeCSYvLw/Z2dlqDyIiIovBjGjFJpUC46MV/y9knQyMjy6Z9WTHjRuHjz/+GF999RXq1KmDt99+W21E81kVK1bEihUrsHXrVgQGBuLXX39VLaEFAFKpFBkZGYiKikLNmjURGRmJiIgIxMTEAACaNm2KIUOG4O2334arqytmzJgBAIiNjUVUVBQ+/vhj1KpVC127dsWJEyfg4+Oj17lIpVJs2bIFUqkUYWFh6N27N6KiojBx4sTiXRw9SMTzky6MpH379rC1tcUff/yh82uePHmCOnXqoGfPnpg0aZLWOhMmTFB15LOysrLg6OhY7PYSERGZhJO/ArHvvrhev1VASM+Sb08pe/z4MZKSkuDv7w87O7ti7WPbfsXqBM/e+OXpqghiI1oaqKGkpqh+y87OhpOTk06xmkksv5WcnIxdu3Zh/Xr95vDY2NggODgYiYmJhdYZO3YsRo0apXqenZ0Nb2/vYreViIjIpDAj2kuLaKlYYouZvcyPSQSysbGxcHNzQ6dOnfR6nVwux7lz59CxY8dC68hkshKfn0FERGQ0yoxombegfZ6sRLEOLzOiFUkqNewSW1Q6jD5HtqCgALGxsejTpw+srdXj6qioKIwdO1b1fOLEidi5cyeuX7+Ov//+G71790ZycjIGDhxY2s0mIiIyDcyIRmWY0Udkd+3ahZSUFPTv319jW0pKCqys/ou1Hzx4gEGDBiEtLQ0uLi5o3LgxDh8+XOJLOxBRKbKEBd0t4RzIvDAjGpVRJnOzV2nRZwIxEZUyS1jQ3RLOgcxXGfwlyhA3e1HpM9TNXkafWkBEBMAyFnS3hHMg86bMiBbSU/GvhQexRAxkicj4LGFBd0s4ByIiM8NAloiMzxIWdLeEcyAiMjMMZInI+LJTDVvPGCzhHIiIzAwDWSIyPktY0N0SzoGITMKNGzcgkUgQHx9v7KaYPAayRGR8ygXdNdbAVJIALt6mvaC7JZwDEVmkZcuWwdnZuUSPMXz4cDRu3BgymQxBQUEleqxnMZAlIuOzhAXdLeEciMqyAjlwZR9w8lfFv7wxU4NcLkdBQUGh2/v374+33367FFvEQJaITIVyQXfnKurlLlUV5eawBqslnANRWRS/HhjnB8xuA8S+q/h3nF+JLplXUFCAGTNmoEaNGpDJZPDx8cHkyZO11tU2orpx40ZIJP/90nzmzBm0adMGFSpUgKOjIxo3boyTJ09i37596NevH7KysiCRSCCRSDBhwgQAQF5eHkaPHo0qVaqgfPnyCA0Nxb59+zSOu3nzZtStWxcymQwpKSla2zhnzhwMGzYM1apVe6nroi+jZ/YiIlIJ6g406GI+C7o/u/i8g5ti4PVpHvDeMsX/c9JN/xyIyjrl+s/PL52nXP+5hH4JHTt2LH744QfMnDkTzZs3R2pqKi5fvlzs/fXq1QvBwcFYuHAhpFIp4uPjYWNjg6ZNm2LWrFn46quvkJCQAABwcHAAAERHR+PixYtYvXo1vLy8sGHDBnTo0AHnzp1DQEAAAODhw4eYPn06fvzxR1SqVAlubm4vf/IGxECWiEyLckF3U6ctg9ezlNm8zOFciMqqF67/LFGs/9ygi0F/Gc3JycHs2bMxb9489OnTBwBQvXp1NG/evNj7TElJwZgxY1C7dm0AUAWiAODk5ASJRAIPDw+1+rGxsUhJSYGXlxcAYPTo0di+fTtiY2MxZcoUAMCTJ0+wYMECNGzYsNhtK0mcWkBEpK/CMng9i9m8iEyfkdZ/vnTpEvLy8vDaa68ZbJ+jRo3CwIEDER4ejmnTpuHatWtF1j937hzkcjlq1qwJBwcH1eOvv/5Se62trS0aNGhgsHYaGkdkiYj0UeQIzrNKbjSHiAzESOs/29vb61XfysoKQqh/5zx58kTt+YQJE/Duu+/izz//xLZt2zB+/HisXr0a3bp107rP3NxcSKVSnDp1ClKp+veTcuqBsq3PzsU1NRyRJSLSxwtHcJ7FbF5EJs1I6z8HBATA3t4eu3fv1qm+q6srcnJy8O+//6rKtK0xW7NmTXz00UfYuXMnunfvjtjYWACKUVW5XH0VhuDgYMjlcqSnp6NGjRpqj2enIJg6BrJERPoozsgMs3kRmSYjrf9sZ2eHTz/9FJ988gl+/vlnXLt2DUePHsXSpUu11g8NDUW5cuXw+eef49q1a1i1ahWWLVum2v7o0SNER0dj3759SE5OxqFDh3DixAnUqVMHAODn54fc3Fzs3r0b9+7dw8OHD1GzZk306tULUVFRWL9+PZKSknD8+HFMnToVf/75p97nlJiYiPj4eKSlpeHRo0eIj49HfHw88vPzi3WNdMVAlohIH8UZmWE2LyLTZMT1n8eNG4ePP/4YX331FerUqYO3334b6enpWutWrFgRK1aswNatWxEYGIhff/1VtYQWAEilUmRkZCAqKgo1a9ZEZGQkIiIiEBMTAwBo2rQphgwZgrfffhuurq6YMWMGACA2NhZRUVH4+OOPUatWLXTt2hUnTpyAj4+P3uczcOBABAcHY/Hixbhy5QqCg4MRHByM27dv639x9CARz0+6sHDZ2dlwcnJCVlYWHB0djd0cIjI3BXLF+pKZt/DiebISxRqyE5M4R5aohDx+/BhJSUnw9/eHnZ1d8XaibRUSF29FEMv1n0tEUf2mT6zGm72IiPShHMH54S0oRmwKC2aZzYvIbJjbGtakwkCWiIzj2WQC5vZDQ5nBq6h1ZF2qcjSHyJyYyxrWpIaBLBGVPm1/xlMmEDCXwO/5ERxlZi9m8yIiKjUMZImodBkpHWSJ4AgOEZFRcdUCIio9L0wHCUUCgQK5lu1ERETqGMgSUekxUjpIIrJ8ZWwRJrNXUFBgkP1wagERlR4jpYMkIstlY2MDiUSCu3fvwtXV1aTTqZLiF478/HzcvXsXVlZWsLW1fan9MZAlotJjpHSQRGS5pFIpqlatin/++Qc3btwwdnNIR+XKlYOPjw+srF5ucgADWSIqPcp0kIUmE/j/BAIGTgdJRJbNwcEBAQEBePLkibGbQjqQSqWwtrY2yOg5A1kiKj1FJhNgAgEiKj6pVAqplN8dZQ1v9iKi0qVMJuBcRb3cpap5Lb1FRERGxxFZIip9ppQO0pwzjBERlXEMZInIOEwhmYAlZBgjIirDOLWAiMomZYax59e1VWYYi19vnHYREZHOGMgSUdnDDGNERBaBgSwRlT3MMEZEZBEYyBJR2cMMY0REFoGBLBGVPcwwRkRkERjIElHZo8wwhsKyykgAF29mGCMiMnEMZImo7FFmGAOgGcwywxgRkblgIEtE5q9ADlzZB5z8VfGvLqsNMMMYmYPivLeJyhCjJkTw8/NDcnKyRvnQoUMxf/58ra9Zu3Ytxo0bhxs3biAgIADTp09Hx44dS7qpRGSqXiapgSllGCN6HhN2EL2QUUdkT5w4gdTUVNUjLi4OANCjRw+t9Q8fPoyePXtiwIABOH36NLp27YquXbvi/PnzpdlsIjIVhkhqoMwwFtJT8S+DWDIFTNhBpBOJEELbiuBGMXLkSGzZsgVXr16FRKJ5E8bbb7+Nf//9F1u2bFGV/e9//0NQUBAWLVqk0zGys7Ph5OSErKwsODo6GqztRFTKCuTAOL8i1oOVKKYJTExicErmhe9tKuP0idVMZo5sfn4+VqxYgf79+2sNYgHgyJEjCA8PVytr3749jhw5Uuh+8/LykJ2drfYgIgvApAZkqfjeJtKZyQSyGzduRGZmJvr27VtonbS0NLi7u6uVubu7Iy0trdDXTJ06FU5OTqqHt7e3oZpMRMbEpAZkqfjeJtKZyQSyS5cuRUREBLy8vAy637FjxyIrK0v1uHnzpkH3T0RGwqQGZKn43ibSmVFXLVBKTk7Grl27sH590ZPXPTw8cOfOHbWyO3fuwMPDo9DXyGQyyGQyg7STiEyIMqlB5i0A2qb6//88QiY1IHPD9zaRzkxiRDY2NhZubm7o1KlTkfXCwsKwe/dutbK4uDiEhYWVZPOIyBQxqQFZKr63iXRm9EC2oKAAsbGx6NOnD6yt1QeIo6KiMHbsWNXzESNGYPv27fjuu+9w+fJlTJgwASdPnkR0dHRpN5uITAGTGpCl4nubSCdGn1qwa9cupKSkoH///hrbUlJSYGX1X6zdtGlTrFq1Cl9++SU+//xzBAQEYOPGjahfv35pNpmIDK1AXvykBExqYFwv03dUNL63yRSY+GfcpNaRLQ1cR5bIxDB7kfli3xFZNiN9xs1yHVkiKoOYvch8se+ILJuZfMYZyBKRcRTIFb/pa70r+//L1o1U1CPTwr4jsmxm9BlnIEtExsHsReaLfUdk2czoM85AloiMg9mLzBf7jsiymdFnnIEsERkHsxeZL/YdkWUzo884A1kiMg5l9iKNBd+VJICLN7MXmSL2HZFlM6PPOANZIjIOZi8yX+w7IstmRp9xBrJEZDzMXmS+2HdEls1MPuNMiEBEhlWcLDAmnjmGisC+I7JsRviM6xOrGT1FLRFZkOJmgbGSAjVbl3jzqASw74gsm4l/xjm1gIgMw0yywBARkeVgIEtEL8+MssAQEZHlYCBLRC/PjLLAEBGR5WAgS0Qvz4yywBARkeVgIEtEL8+MssAQEZHlYCBLRC/PjLLAEBGR5WAgS0Qvz4yywBARkeVgIEsWSS4HjsQDm3Yr/pXzZvmSZyZZYIiIyHIwIQJZnG37gZh5QOrd/8o8XYHx0UBES+O1q0wI6g406MJMT0REVCqYopYsyrb9wAfjNVczVf6xe2EMg1kiIiJTpk+sxqkFZDHkcsVIbBFL8iNmHqcZEBERWQoGsmQxjp9Tn07wPAHF9uPnSq1JREREVIIYyJLFSM8wbD0iIiIybcW62Wv37t3YvXs30tPTUVBQoLbtp59+MkjDiPTlVsmw9YiIiMi06R3IxsTEYOLEiQgJCYGnpyckksIWQCcqXU0CFasTpN3VPk9WAsDDVVGPiIiIzJ/egeyiRYuwbNkyvPfeeyXRHqJik0oVS2x9MF4RtD4bzCp/3RofrahHRERE5k/vObL5+flo2rRpSbSF6KVFtFQsseXhql7u4cqlt4iIiCyN3uvIfvrpp3BwcMC4ceNKqk0liuvIlg1yuWJ1gvQMxZzYJoEciSUiIjIH+sRqek8tePz4MZYsWYJdu3ahQYMGsLGxUdv+/fff67tLIoOTSoGwIGO3goiIiEqS3oHs2bNnERQUBAA4f/682jbe+EVEREREpUXvQHbv3r0l0Q4iIiIiIr28VEKEf/75B//884+h2kJEREREpDO9A9mCggJMnDgRTk5O8PX1ha+vL5ydnTFp0iSN5AhERERERCVF76kFX3zxBZYuXYpp06ahWbNmAICDBw9iwoQJePz4MSZPnmzwRhIRERERPU/v5be8vLywaNEivPHGG2rlmzZtwtChQ3Hr1i2DNtDQuPwWERERkenSJ1bTe2rB/fv3Ubt2bY3y2rVr4/79+/rujoiIiIioWPQOZBs2bIh58+ZplM+bNw8NGzY0SKNIQS4HjsQDm3Yr/pXLzfMY5orXpmi8PkREZGx6z5GdMWMGOnXqhF27diEsLAwAcOTIEdy8eRNbt27VuwG3bt3Cp59+im3btuHhw4eoUaMGYmNjERISorX+vn370KZNG43y1NRUeHh46H18U7VtPxAzD0i9+1+ZpyswPtpwaVZL4xjmitemaLw+RERkCvQekW3VqhWuXLmCbt26ITMzE5mZmejevTsSEhLQokULvfb14MEDNGvWDDY2Nti2bRsuXryI7777Di4uLi98bUJCAlJTU1UPNzc3fU/FZG3bD3wwXj1IAIC0u4rybfvN4xjmitemaLw+RERkKvS+2cuQPvvsMxw6dAgHDhzQ+TXKEdkHDx7A2dlZ72Oa+s1ecjnQrKdmkKAkAeDhChz6VZGG1VSPYa54bYrG60NERCXN4Dd7nT17VrVG7NmzZ4t86GPz5s0ICQlBjx494ObmhuDgYPzwww86vTYoKAienp5o27YtDh06VGi9vLw8ZGdnqz1M2fFzhQcJACCg2H78nGkfw1zx2hSN14eIiEyJTnNkg4KCkJaWBjc3NwQFBUEikUDbQK5EIoFcjzs+rl+/joULF2LUqFH4/PPPceLECQwfPhy2trbo06eP1td4enpi0aJFCAkJQV5eHn788Ue0bt0ax44dQ6NGjTTqT506FTExMTq3ydjSMwxbz1jHMFe8NkXj9SEiIlOiUyCblJQEV1dX1f8NpaCgACEhIZgyZQoAIDg4GOfPn8eiRYsKDWRr1aqFWrVqqZ43bdoU165dw8yZM/HLL79o1B87dixGjRqlep6dnQ1vb2+DnYOhuVUybD1jHcNc8doUjdeHiIhMiU5TC3x9fSGRSAAAycnJqFKliio9rfJRpUoVJCcn63VwT09P1K1bV62sTp06SElJ0Ws/TZo0QWJiotZtMpkMjo6Oag9T1iRQcfe3pJDtEii2Nwk07WOYK16bovH6EBGRKdF71YI2bdpoTXyQlZWldVmsojRr1gwJCQlqZVeuXIGvr69e+4mPj4enp6derzFVUqliCSNAM1hQPh8f/XI30pTGMcwVr03ReH2IiMiU6B3ICiFUo7PPysjIQPny5fXa10cffYSjR49iypQpSExMxKpVq7BkyRIMGzZMVWfs2LGIiopSPZ81axY2bdqExMREnD9/HiNHjsSePXvUXmPuIloCC2MUd38/y8NVUW6IdTpL4xjmitemaLw+RERkKnROiNC9e3cAihu6+vbtC5lMptoml8tx9uxZNG3aVK+Dv/LKK9iwYQPGjh2LiRMnwt/fH7NmzUKvXr1UdVJTU9WmGuTn5+Pjjz/GrVu3UK5cOTRo0AC7du3SezTYFMjliru70zMUcwqbBP43khXREmjXrPDthlAaxzBXvDZF4/UhIiJToPM6sv369QMALF++HJGRkbC3t1dts7W1hZ+fHwYNGoTKlSuXTEsNxFTWkWVmJCIiIiJN+sRqOo/IxsbGAgD8/PwwZswYlCtX7uVaWYYpMyM9/xuEMjMS/zxLRERE9GJ6z5GNiorCrVu3NMqvXr2KGzduGKJNFk0uV4zEahsGV5bFzFPUIyIiIqLC6R3I9u3bF4cPH9YoP3bsGPr27WuINlk0ZkYiIiIiMgy9A9nTp0+jWbNmGuX/+9//EB8fb4g2WTRmRiIiIiIyDL0DWYlEgpycHI3yrKwsvdLTllXMjERERERkGHoHsi1btsTUqVPVgla5XI6pU6eiefPmBm2cJWJmJCIiIiLD0HnVAqXp06ejZcuWqFWrFlq0aAEAOHDgALKzs7Fnzx6DN9DSKDMjfTBeEbQ+e9MXMyMRERER6U7vEdm6devi7NmziIyMRHp6OnJychAVFYXLly+jfv36JdFGsyaXA0figU27Ff/K5cyMZM609ScREREZh84JESxFaSZEeFHSg6Iye5HpYRILIiKikqdPrFbsQPbhw4dISUlBfn6+WnmDBg2Ks7tSU1qBbGFJD5TTBzjyal7Yn0RERKWjRAPZu3fvol+/fti2bZvW7aa+ckFpBLJyOdCsZ+HrxUqgmEZw6FeOwJoD9icREVHp0SdW03uO7MiRI5GZmYljx47B3t4e27dvx/LlyxEQEIDNmzcXu9GWhEkPLAv7k4iIyDTpvWrBnj17sGnTJoSEhMDKygq+vr5o27YtHB0dMXXqVHTq1Kkk2mlWmPTAsrA/iYiITJPeI7L//vsv3NzcAAAuLi64e1cxVBUYGIi///7bsK0zU0x6YFnYn0RERKZJ70C2Vq1aSEhIAAA0bNgQixcvxq1bt7Bo0SJ4enoavIHmiEkPLAv7k4iIyDTpHciOGDECqampAIDx48dj27Zt8PHxwZw5czBlyhSDN9AcKZMeAJrBD5MemB/2JxERkWnSadWC7OzsQu8ae/jwIS5fvgwfHx9UrlzZ4A00NFNaR5bMC/uTiIio5Bl8+S2pVIrU1FS4ubnh1Vdfxfr16+Hs7Gyo9paq0gxkASY90JepXy9Tbx8REZG50ydW02nVAgcHB2RkZMDNzQ379u3DkydPDNLQskAqBcKCjN0K82AOI57sTyIiItOhUyAbHh6ONm3aoE6dOgCAbt26wdbWVmvdPXv2GK51VGYUljkr7a6inJmziIiI6Hk6BbIrVqzA8uXLce3aNfz111+oV68eypUrV9JtozJCLleMxGqb4yKguKEqZh7Qrhn/jE9ERET/0SmQtbe3x5AhQwAAJ0+exPTp0812jiyZHn0yZ/HP+kRERKSk9/Jbe/fuVQti5XI54uPj8eDBA0O2i8oQZs4iIiKi4tA7kB05ciSWLl0KQBHEtmzZEo0aNYK3tzf27dtn6PZRGcDMWURERFQcegeya9euRcOGDQEAf/zxB27cuIHLly/jo48+whdffGHwBpLlY+YsIiIiKg69A9mMjAx4eHgAALZu3YoePXqgZs2a6N+/P86dO2fwBpLlY+YsIiIiKg69A1l3d3dcvHgRcrkc27dvR9u2bQEoMnxJGWmUSXI5cCQe2LRb8a9crv8+IloqltjycFUv93Dl0ltERESknU6rFjyrX79+iIyMhKenJyQSCcLDwwEAx44dQ+3atQ3eQDJthkxiENFSscQWM2cRERGRLnRKUfu8devW4ebNm+jRoweqVq0KAFi+fDmcnZ3RpUsXgzfSkEo7Ra0lKyyJgXI6AEdSiYiISF/6xGrFCmTNGQNZw5DLgWY9C1//VQLFtIBDv3JElYiIiHSnT6ym09SCOXPmYPDgwbCzs8OcOXOKrDt8+HDdW0pmi0kMiIiIyNh0CmRnzpyJXr16wc7ODjNnziy0nkQiYSBbRjCJARERERmbToFsUlKS1v9T2cUkBkRERGRsei+/NXHiRDx8+FCj/NGjR5g4caJBGkWmj0kMiIiIyNj0DmRjYmKQm5urUf7w4UPExMQYpFFk+pjEgIiIiIxN70BWCAGJRHMc7syZM6hYsaJBGkXmgUkMiIiIyJh0DmRdXFxQsWJFSCQS1KxZExUrVlQ9nJyc0LZtW0RGRurdgFu3bqF3796oVKkS7O3tERgYiJMnTxb5mn379qFRo0aQyWSoUaMGli1bpvdxyTAiWiqW2Fo9E5jzpeLfQ78yiH1ZhsiWRkREZOl0zuw1a9YsCCHQv39/xMTEwMnJSbXN1tYWfn5+CAsL0+vgDx48QLNmzdCmTRts27YNrq6uuHr1KlxcXAp9TVJSEjp16oQhQ4Zg5cqV2L17NwYOHAhPT0+0b99er+OTYUilXGLLkAyZLY2IiMiS6Z0Q4a+//kLTpk1hY2Pz0gf/7LPPcOjQIRw4cEDn13z66af4888/cf78eVXZO++8g8zMTGzfvv2Fr2dCBDJlzJZGRERlnT6xmt5zZFu1aqUKYh8/fozs7Gy1hz42b96MkJAQ9OjRA25ubggODsYPP/xQ5GuOHDmC8PBwtbL27dvjyJEj+p0IkYmRyxUjsdp+s1SWxczjNAMiIiIlvQPZhw8fIjo6Gm5ubihfvjxcXFzUHvq4fv06Fi5ciICAAOzYsQMffPABhg8fjuXLlxf6mrS0NLi7u6uVubu7Izs7G48ePdKon5eX91LBNlFp0SdbGhERERUjkB0zZgz27NmDhQsXQiaT4ccff0RMTAy8vLzw888/67WvgoICNGrUCFOmTEFwcDAGDx6MQYMGYdGiRfo2q1BTp06Fk5OT6uHt7W2wfRMZErOlERER6UfvQPaPP/7AggUL8Oabb8La2hotWrTAl19+iSlTpmDlypV67cvT0xN169ZVK6tTpw5SUlIKfY2Hhwfu3LmjVnbnzh04OjrC3t5eo/7YsWORlZWlety8eVOvNhKVFmZLIyIi0o/egez9+/dRrVo1AICjoyPu378PAGjevDn279+v176aNWuGhIQEtbIrV67A19e30NeEhYVh9+7damVxcXGFrpggk8ng6Oio9iAyRcyWRkREpB+9A9lq1aohKSkJAFC7dm2sWbMGgGKk1tnZWa99ffTRRzh69CimTJmCxMRErFq1CkuWLMGwYcNUdcaOHYuoqCjV8yFDhuD69ev45JNPcPnyZSxYsABr1qzBRx99pO+pEJkUZksjIiLSj96BbL9+/XDmzBkAiuWz5s+fDzs7O3z00UcYM2aMXvt65ZVXsGHDBvz666+oX78+Jk2ahFmzZqFXr16qOqmpqWpTDfz9/fHnn38iLi4ODRs2xHfffYcff/yRa8iaKH0X9i/riQCYLY2IiEh3eq8j+7zk5GScOnUKNWrUQIMGDQzVrhLDdWRLj74L+zMRwH/kcsXqBOkZijmxTQI5EktERGWDPrHaSweyAJCZman3tAJjYSBbOvRd2J+JAIiIiAgo4YQI06dPx2+//aZ6HhkZiUqVKqFKlSqqKQdUtum7sD8TARAREVFx6B3ILlq0SLUWa1xcHOLi4rBt2zZEREToPUeWLJO+C/szEQAREREVh7W+L0hLS1MFslu2bEFkZCTatWsHPz8/hIaGGryBZH70XdifiQCIiIioOPQekXVxcVElFdi+fTvCw8MBAEIIyPm3X4L+C/szEQAREREVh94jst27d8e7776LgIAAZGRkICIiAgBw+vRp1KhRw+ANJPOjXNg/7a72ea8SKJaTUi7sr299IiIiIqAYI7IzZ85EdHQ06tati7i4ODg4OABQrPc6dOhQgzeQzI++C/szEQAREREVh0GW3zInXH6r9HAdWSIiItJXqa8ja04sNZA11QX09W2XqZ4HERERlQ59YjW958iS6THlkUypFAgLKrn6REREVHbpPUeWTIsyI9bz67Cm3VWUb9tvnHYRERERlTQGsmaMGbGIiIioLCtWIJuZmYkff/wRY8eOxf379wEAf//9N27dumXQxlHRmBGLiIiIyjK958iePXsW4eHhcHJywo0bNzBo0CBUrFgR69evR0pKCn7++eeSaCdpwYxYREREVJbpPSI7atQo9O3bF1evXoWdnZ2qvGPHjti/nxMySxMzYhEREVFZpncge+LECbz//vsa5VWqVEFaWppBGkW6UWbEej6JgJIEiu3MiEVERESWSO9AViaTITs7W6P8ypUrcHV1NUijSDfMiEVERERlmd6B7BtvvIGJEyfiyZMnAACJRIKUlBR8+umnePPNNw3eQCpaREtgYQzg8dzvEB6uinJjryNrbHI5cCQe2LRb8S9XcCAiIrIcemf2ysrKwltvvYWTJ08iJycHXl5eSEtLQ1hYGLZu3Yry5cuXVFsNgpm9yg5TThRBRERE2pVKitpDhw7hzJkzyM3NRaNGjRAeHl6sxpY2Sw1kSZ0yUcTzb27llAuOVhMREZkmgweyFStWxJUrV1C5cmX0798fs2fPRoUKFQzW4NLEQNbyyeVAs56Fr7ErgWLqxaFfOWpNRERkavSJ1XSaI5ufn6+6wWv58uV4/Pjxy7eSqIQwUQQREVHZoFNChLCwMHTt2hWNGzeGEALDhw+Hvb291ro//fSTQRtIpC8miiAiIiobdApkV6xYgZkzZ+LatWuQSCTIysriqCyZLCaKICIiKhv0vtnL398fJ0+eRKVK5hkFcI6s5VPOkU27q3mzF8A5skRERKbM4HNkn5WUlGS2QSyVDUwUQUREVDboNLVgzpw5GDx4MOzs7DBnzpwi6w4fPtwgDSN6GcpEEc+vI+vBdWSJiIgshk5TC56dTuDv71/4ziQSXL9+3aANNDROLTAcc0jCYA5tJCIiov/oE6vpNCKblJSk9f9UdplL1iypFAgLMnYriIiIqCToPUeWSJk16/m1WtPuKsq37TdOu4iIiKhs0WlEdtSoUTrv8Pvvvy92Y8j0yeWKkVht81EEFDdTxcwD2jXjn/CJiIioZOkUyJ4+fVqnnUkkz98jTpZGn6xZ/JM+ERERlSSdAtm9e/eWdDvITDBrFhEREZkKzpElvTBrFhEREZkKBrKklyaBitUJCptEIoFie5PA0mwVERERlUUMZEkvzJpFREREpoKBLOlNmTXLw1W93MNVUW5K68gSERGR5TJqIDthwgRIJBK1R+3atQutv2zZMo36dnZ2pdhi0yWXA0figU27Ff/K5SV7vIiWwKFfgdUzgTlfKv499CuDWCIiIio9Oq1aUJLq1auHXbt2qZ5bWxfdJEdHRyQkJKiec8kv42XZYtYsIiIiMiajB7LW1tbw8PDQub5EItGrvqVTZtl6PkGBMssW/9RPRERElsroc2SvXr0KLy8vVKtWDb169UJKSkqR9XNzc+Hr6wtvb2906dIFFy5cKKWWmp4XZdkCFNtLepoBERERkTEYNZANDQ3FsmXLsH37dixcuBBJSUlo0aIFcnJytNavVasWfvrpJ2zatAkrVqxAQUEBmjZtin/++afQY+Tl5SE7O1vtYSn0ybJFREREZGmMOrUgIiJC9f8GDRogNDQUvr6+WLNmDQYMGKBRPywsDGFhYarnTZs2RZ06dbB48WJMmjRJ6zGmTp2KmJgYwzfeBDDLFhEREZVlRp9a8CxnZ2fUrFkTiYmJOtW3sbFBcHBwkfXHjh2LrKws1ePmzZuGaq7RMcsWERERlWUmFcjm5ubi2rVr8PT01Km+XC7HuXPniqwvk8ng6Oio9rAUzLJFREREZZlRA9nRo0fjr7/+wo0bN3D48GF069YNUqkUPXv2BABERUVh7NixqvoTJ07Ezp07cf36dfz999/o3bs3kpOTMXDgQGOdglExyxYRERGVZUadI/vPP/+gZ8+eyMjIgKurK5o3b46jR4/C1VWRMiolJQVWVv/F2g8ePMCgQYOQlpYGFxcXNG7cGIcPH0bdunWNdQpGp8yy9fw6sh6lsI6svuRyxY1n6RmK6Q5NAksmyC6t4xAREZFxSYQQ2lZvsljZ2dlwcnJCVlaWRU0zMPXgrbSSNhgrOQQREREZhj6xGgNZKnGFJW1QTn8wVNKG0joOERERlRx9YjWTutmLLE9pJW1gcggiIqKyh4EslajSStrA5BBERERlDwNZKlGllbSBySGIiIjKHgayVKJKK2kDk0MQERGVPQxkqUSVVtIGJocgIiIqexjIUokqraQNTA5BRERU9jCQpRKnTNrg4ape7uFq2CWxSus4REREZBq4jiyVGmb2IiIiohfRJ1YzaopaKlukUiAsyHKOQ0RERMbFqQVEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmyaiB7IQJEyCRSNQetWvXLvI1a9euRe3atWFnZ4fAwEBs3bq1lFpLRERERKbE6COy9erVQ2pqqupx8ODBQusePnwYPXv2xIABA3D69Gl07doVXbt2xfnz50uxxURERERkCoweyFpbW8PDw0P1qFy5cqF1Z8+ejQ4dOmDMmDGoU6cOJk2ahEaNGmHevHml2GIiIiIiMgVGD2SvXr0KLy8vVKtWDb169UJKSkqhdY8cOYLw8HC1svbt2+PIkSOFviYvLw/Z2dlqDyIiIiIyf0YNZENDQ7Fs2TJs374dCxcuRFJSElq0aIGcnByt9dPS0uDu7q5W5u7ujrS0tEKPMXXqVDg5Oake3t7eBj0HIiIiIjIOowayERER6NGjBxo0aID27dtj69atyMzMxJo1awx2jLFjxyIrK0v1uHnzpsH2TURERETGY23sBjzL2dkZNWvWRGJiotbtHh4euHPnjlrZnTt34OHhUeg+ZTIZZDKZQdtJRERERMZn9Dmyz8rNzcW1a9fg6empdXtYWBh2796tVhYXF4ewsLDSaB4RERERmRCjBrKjR4/GX3/9hRs3buDw4cPo1q0bpFIpevbsCQCIiorC2LFjVfVHjBiB7du347vvvsPly5cxYcIEnDx5EtHR0cY6BSIiIiIyEqNOLfjnn3/Qs2dPZGRkwNXVFc2bN8fRo0fh6uoKAEhJSYGV1X+xdtOmTbFq1Sp8+eWX+PzzzxEQEICNGzeifv36xjoFIiIiIjISiRBCGLsRpSk7OxtOTk7IysqCo6OjsZtDRERERM/QJ1YzqTmyRERERES6YiBLRERERGaJgSwRERERmSUGskRERERklhjIEhEREZFZYiBLRERERGaJgSwRERERmSUGskRERERklhjIEhEREZFZYiBLRERERGaJgSwRERERmSUGskRERERklhjIEhEREZFZYiBLRERERGaJgSwRERERmSUGskRERERklhjIEhEREZFZsjZ2AyyZXA4cPwekZwBulYAmgYBUauxWEREREVkGBrIlZNt+IGYekHr3vzJPV2B8NBDR0njtIiIiIrIUnFpQArbtBz4Yrx7EAkDaXUX5tv3GaRcRERGRJWEga2ByuWIkVmjZpiyLmaeoR0RERETFx0DWwI6f0xyJfZaAYvvxc6XWJCIiIiKLxEDWwNIzDFuPiIiIiLRjIGtgbpUMW4+IiIiItGMga2BNAhWrE0gK2S6BYnuTwNJsFREREZHlYSBrYFKpYoktQDOYVT4fH831ZImIiIheFgPZEhDRElgYA3i4qpd7uCrKuY4sERER0ctjQoQSEtESaNeMmb2IiIiISgoD2RIklQJhQcZuBREREZFl4tQCIiIiIjJLDGSJiIiIyCwxkCUiIiIis8RAloiIiIjMEgNZIiIiIjJLDGSJiIiIyCyVueW3hBAAgOzsbCO3hIiIiIiep4zRlDFbUcpcIJuTkwMA8Pb2NnJLiIiIiKgwOTk5cHJyKrKOROgS7lqQgoICJCQkoG7durh58yYcHR2N3SR6gezsbHh7e7O/zAD7yrywv8wL+8t8sK9ejhACOTk58PLygpVV0bNgy9yIrJWVFapUqQIAcHR05BvMjLC/zAf7yrywv8wL+8t8sK+K70UjsUq82YuIiIiIzBIDWSIiIiIyS2UykJXJZBg/fjxkMpmxm0I6YH+ZD/aVeWF/mRf2l/lgX5WeMnezFxERERFZhjI5IktERERE5o+BLBERERGZJQayRERERGSWymQgO3/+fPj5+cHOzg6hoaE4fvy4sZtkUaZOnYpXXnkFFSpUgJubG7p27YqEhAS1Oo8fP8awYcNQqVIlODg44M0338SdO3fU6qSkpKBTp04oV64c3NzcMGbMGDx9+lStzr59+9CoUSPIZDLUqFEDy5Yt02gP+1t306ZNg0QiwciRI1Vl7CvTcuvWLfTu3RuVKlWCvb09AgMDcfLkSdV2IQS++uoreHp6wt7eHuHh4bh69araPu7fv49evXrB0dERzs7OGDBgAHJzc9XqnD17Fi1atICdnR28vb0xY8YMjbasXbsWtWvXhp2dHQIDA7F169aSOWkzJZfLMW7cOPj7+8Pe3h7Vq1fHpEmT1NJusr+MY//+/ejcuTO8vLwgkUiwceNGte2m1C+6tKVME2XM6tWrha2trfjpp5/EhQsXxKBBg4Szs7O4c+eOsZtmMdq3by9iY2PF+fPnRXx8vOjYsaPw8fERubm5qjpDhgwR3t7eYvfu3eLkyZPif//7n2jatKlq+9OnT0X9+vVFeHi4OH36tNi6dauoXLmyGDt2rKrO9evXRbly5cSoUaPExYsXxdy5c4VUKhXbt29X1WF/6+748ePCz89PNGjQQIwYMUJVzr4yHffv3xe+vr6ib9++4tixY+L69etix44dIjExUVVn2rRpwsnJSWzcuFGcOXNGvPHGG8Lf3188evRIVadDhw6iYcOG4ujRo+LAgQOiRo0aomfPnqrtWVlZwt3dXfTq1UucP39e/Prrr8Le3l4sXrxYVefQoUNCKpWKGTNmiIsXL4ovv/xS2NjYiHPnzpXOxTADkydPFpUqVRJbtmwRSUlJYu3atcLBwUHMnj1bVYf9ZRxbt24VX3zxhVi/fr0AIDZs2KC23ZT6RZe2lGVlLpBt0qSJGDZsmOq5XC4XXl5eYurUqUZslWVLT08XAMRff/0lhBAiMzNT2NjYiLVr16rqXLp0SQAQR44cEUIovmSsrKxEWlqaqs7ChQuFo6OjyMvLE0II8cknn4h69eqpHevtt98W7du3Vz1nf+smJydHBAQEiLi4ONGqVStVIMu+Mi2ffvqpaN68eaHbCwoKhIeHh/jmm29UZZmZmUImk4lff/1VCCHExYsXBQBx4sQJVZ1t27YJiUQibt26JYQQYsGCBcLFxUXVf8pj16pVS/U8MjJSdOrUSe34oaGh4v3333+5k7QgnTp1Ev3791cr6969u+jVq5cQgv1lKp4PZE2pX3RpS1lXpqYW5Ofn49SpUwgPD1eVWVlZITw8HEeOHDFiyyxbVlYWAKBixYoAgFOnTuHJkydq/VC7dm34+Pio+uHIkSMIDAyEu7u7qk779u2RnZ2NCxcuqOo8uw9lHeU+2N+6GzZsGDp16qRxPdlXpmXz5s0ICQlBjx494ObmhuDgYPzwww+q7UlJSUhLS1O7jk5OTggNDVXrL2dnZ4SEhKjqhIeHw8rKCseOHVPVadmyJWxtbVV12rdvj4SEBDx48EBVp6g+JaBp06bYvXs3rly5AgA4c+YMDh48iIiICADsL1NlSv2iS1vKujIVyN67dw9yuVztBy4AuLu7Iy0tzUitsmwFBQUYOXIkmjVrhvr16wMA0tLSYGtrC2dnZ7W6z/ZDWlqa1n5SbiuqTnZ2Nh49esT+1tHq1avx999/Y+rUqRrb2Fem5fr161i4cCECAgKwY8cOfPDBBxg+fDiWL18O4L/rXdR1TEtLg5ubm9p2a2trVKxY0SB9yv76z2effYZ33nkHtWvXho2NDYKDgzFy5Ej06tULAPvLVJlSv+jSlrLO2tgNIMs2bNgwnD9/HgcPHjR2U0iLmzdvYsSIEYiLi4OdnZ2xm0MvUFBQgJCQEEyZMgUAEBwcjPPnz2PRokXo06ePkVtHz1uzZg1WrlyJVatWoV69eoiPj8fIkSPh5eXF/iIykDI1Ilu5cmVIpVKNO67v3LkDDw8PI7XKckVHR2PLli3Yu3cvqlatqir38PBAfn4+MjMz1eo/2w8eHh5a+0m5rag6jo6OsLe3Z3/r4NSpU0hPT0ejRo1gbW0Na2tr/PXXX5gzZw6sra3h7u7OvjIhnp6eqFu3rlpZnTp1kJKSAuC/613UdfTw8EB6erra9qdPn+L+/fsG6VP213/GjBmjGpUNDAzEe++9h48++kj11w/2l2kypX7RpS1lXZkKZG1tbdG4cWPs3r1bVVZQUIDdu3cjLCzMiC2zLEIIREdHY8OGDdizZw/8/f3Vtjdu3Bg2NjZq/ZCQkICUlBRVP4SFheHcuXNqXxRxcXFwdHRU/SAPCwtT24eyjnIf7O8Xe+2113Du3DnEx8erHiEhIejVq5fq/+wr09GsWTONpeyuXLkCX19fAIC/vz88PDzUrmN2djaOHTum1l+ZmZk4deqUqs6ePXtQUFCA0NBQVZ39+/fjyZMnqjpxcXGoVasWXFxcVHWK6lMCHj58CCsr9R+zUqkUBQUFANhfpsqU+kWXtpR5xr7brLStXr1ayGQysWzZMnHx4kUxePBg4ezsrHbHNb2cDz74QDg5OYl9+/aJ1NRU1ePhw4eqOkOGDBE+Pj5iz5494uTJkyIsLEyEhYWptiuXdGrXrp2Ij48X27dvF66urlqXdBozZoy4dOmSmD9/vtYlndjf+nl21QIh2Fem5Pjx48La2lpMnjxZXL16VaxcuVKUK1dOrFixQlVn2rRpwtnZWWzatEmcPXtWdOnSReuyQcHBweLYsWPi4MGDIiAgQG3ZoMzMTOHu7i7ee+89cf78ebF69WpRrlw5jWWDrK2txbfffisuXbokxo8fX6aXc9KmT58+okqVKqrlt9avXy8qV64sPvnkE1Ud9pdx5OTkiNOnT4vTp08LAOL7778Xp0+fFsnJyUII0+oXXdpSlpW5QFYIIebOnSt8fHyEra2taNKkiTh69Kixm2RRAGh9xMbGquo8evRIDB06VLi4uIhy5cqJbt26idTUVLX93LhxQ0RERAh7e3tRuXJl8fHHH4snT56o1dm7d68ICgoStra2olq1amrHUGJ/6+f5QJZ9ZVr++OMPUb9+fSGTyUTt2rXFkiVL1LYXFBSIcePGCXd3dyGTycRrr70mEhIS1OpkZGSInj17CgcHB+Ho6Cj69esncnJy1OqcOXNGNG/eXMhkMlGlShUxbdo0jbasWbNG1KxZU9ja2op69eqJP//80/AnbMays7PFiBEjhI+Pj7CzsxPVqlUTX3zxhdpyTOwv49i7d6/Wn1N9+vQRQphWv+jSlrJMIsQzKUaIiIiIiMxEmZojS0RERESWg4EsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RERERmiYEsEREREZklBrJEREREZJYYyBIRERGRWWIgS0RURvn5+WHWrFkltv+WLVti1apVJbZ/XWzfvh1BQUEoKCgwajuIqGQwkCUik5eWloYRI0agRo0asLOzg7u7O5o1a4aFCxfi4cOHqnp+fn6QSCSQSCSwt7eHn58fIiMjsWfPHrX93bhxQ1VPIpGgUqVKaNeuHU6fPl3ap2ZUJ06cwODBg1XPJRIJNm7caJB9b968GXfu3ME777zzwv337dsXXbt2VT1PSkrCu+++Cy8vL9jZ2aFq1aro0qULLl++rLYv5aN8+fIICAhA3759cerUKbV9d+jQATY2Nli5cqVBzouITAsDWSIyadevX0dwcDB27tyJKVOm4PTp0zhy5Ag++eQTbNmyBbt27VKrP3HiRKSmpiIhIQE///wznJ2dER4ejsmTJ2vse9euXUhNTcWOHTuQm5uLiIgIZGZmltKZKTx58qRUj/csV1dXlCtXrkT2PWfOHPTr1w9WVvr9mHny5Anatm2LrKwsrF+/HgkJCfjtt98QGBio0TexsbFITU3FhQsXMH/+fOTm5iI0NBQ///yzWr2+fftizpw5L3tKRGSKBBGRCWvfvr2oWrWqyM3N1bq9oKBA9X9fX18xc+ZMjTpfffWVsLKyEpcvXxZCCJGUlCQAiNOnT6vqHDp0SAAQ27dv13qc8ePHi4YNG4pFixaJqlWrCnt7e9GjRw+RmZmpVu+HH34QtWvXFjKZTNSqVUvMnz9ftU153NWrV4uWLVsKmUwmYmNjtR7vwYMHYvDgwcLNzU3IZDJRr1498ccffwghhLh375545513hJeXl7C3txf169cXq1atUnt9q1atxLBhw8SwYcOEo6OjqFSpkvjyyy8LvV6+vr4CgOrh6+srhBAiMTFRvPHGG8LNzU2UL19ehISEiLi4OK1tVkpPTxcSiUScP39erRyA2LBhg0b9Pn36iC5dugghhDh9+rQAIG7cuFHkMQrbV1RUlKhQoYK4f/++qiw5OVkAEImJiUXuk4jMD0dkichkZWRkYOfOnRg2bBjKly+vtY5EInnhfkaMGAEhBDZt2lRoHXt7ewBAfn5+oXUSExOxZs0a/PHHH9i+fTtOnz6NoUOHqravXLkSX331FSZPnoxLly5hypQpGDduHJYvX662n88++wwjRozApUuX0L59e43jFBQUICIiAocOHcKKFStw8eJFTJs2DVKpFADw+PFjNG7cGH/++SfOnz+PwYMH47333sPx48fV9rN8+XJYW1vj+PHjmD17Nr7//nv8+OOPWs/txIkTAP4b5VQ+z83NRceOHbF7926cPn0aHTp0QOfOnZGSklLodTp48CDKlSuHOnXqFFqnMK6urrCyssK6desgl8v1fv1HH32EnJwcxMXFqcp8fHzg7u6OAwcO6L0/IjJt1sZuABFRYRITEyGEQK1atdTKK1eujMePHwMAhg0bhunTpxe5n4oVK8LNzQ03btzQuj0zMxOTJk2Cg4MDmjRpUuh+Hj9+jJ9//hlVqlQBAMydOxedOnXCd999Bw8PD4wfPx7fffcdunfvDgDw9/fHxYsXsXjxYvTp00e1n5EjR6rqaLNr1y4cP34cly5dQs2aNQEA1apVU22vUqUKRo8erXr+4YcfYseOHVizZo1a+729vTFz5kxIJBLUqlUL586dw8yZMzFo0CCNY7q6ugIAnJ2d4eHhoSpv2LAhGjZsqHo+adIkbNiwAZs3b0Z0dLTW9icnJ8Pd3V3vaQXKc5szZw4++eQTxMTEICQkBG3atEGvXr3UrkFhateuDQAafe3l5YXk5GS920NEpo0jskRkdo4fP474+HjUq1cPeXl5Or1GCKExetu0aVM4ODjAxcUFZ86cwW+//QZ3d/dC9+Hj46MKYgEgLCwMBQUFSEhIwL///otr165hwIABcHBwUD2+/vprXLt2TW0/ISEhRbY1Pj4eVatWVQWxz5PL5Zg0aRICAwNRsWJFODg4YMeOHRqjpP/73//UzjksLAxXr17Va6QzNzcXo0ePRp06deDs7AwHBwdcunSpyBHZR48ewc7OTudjPG/YsGFIS0vDypUrERYWhrVr16JevXpqo6yFEUIA0Bypt7e3V7sxkIgsA0dkichk1ahRAxKJBAkJCWrlypE55XSAF8nIyMDdu3fh7++vVv7bb7+hbt26qFSpEpydnV+qrbm5uQCAH374AaGhoWrblFMClAqbJqH0ovP65ptvMHv2bMyaNQuBgYEoX748Ro4cWeS0iOIaPXo04uLi8O2336JGjRqwt7fHW2+9VeSxKleujAcPHmiUV6hQAVlZWRrlmZmZcHJy0qjbuXNndO7cGV9//TXat2+Pr7/+Gm3bti2yvZcuXQIAjb6+f/++atSZiCwHR2SJyGRVqlQJbdu2xbx58/Dvv/8Wez+zZ8+GlZWV2hJPgOJP79WrV9c5iE1JScHt27dVz48ePQorKyvUqlUL7u7u8PLywvXr11GjRg21x/NB1Ys0aNAA//zzD65cuaJ1+6FDh9ClSxf07t0bDRs2RLVq1bTWPXbsmNrzo0ePIiAgQCOwVrKxsdEYrT106BD69u2Lbt26ITAwEB4eHoVO0VAKDg5GWlqaRjBbq1YtjeWx5HI5zpw5U+joM6AYXa1du7ZO74FZs2bB0dER4eHhqrLHjx/j2rVrCA4OfuHrici8MJAlIpO2YMECPH36FCEhIfjtt99w6dIlJCQkYMWKFbh8+bJGUJaTk4O0tDTcvHkT+/fvx+DBg/H1119j8uTJqFGjxku1xc7ODn369MGZM2dw4MABDB8+HJGRkao5pTExMZg6dSrmzJmDK1eu4Ny5c4iNjcX333+v13FatWqFli1b4s0330RcXBySkpKwbds2bN++HQAQEBCAuLg4HD58GJcuXcL777+PO3fuaOwnJSUFo0aNQkJCAn799VfMnTsXI0aMKPS4fn5+2L17t1oQGhAQgPXr1yM+Ph5nzpzBu++++8LkAsHBwahcuTIOHTqkVj5q1Cj8+OOPWLBgAa5evYr4+HgMHjwYDx48wMCBAwEoplV06dIF69atw8WLF5GYmIilS5fip59+QpcuXdT2l5mZibS0NCQnJyMuLg5vvfUWVq1ahYULF6r9cnL06FHIZDKEhYUV2W4iMkPGXTSBiOjFbt++LaKjo4W/v7+wsbERDg4OokmTJuKbb74R//77r6res0tI2draCh8fHxEZGSn27Nmjtj9ty2+9iHL5rQULFggvLy9hZ2cn3nrrLbVlnoQQYuXKlSIoKEjY2toKFxcX0bJlS7F+/Xq9j5uRkSH69esnKlWqJOzs7ET9+vXFli1bVNu6dOkiHBwchJubm/jyyy9FVFSUagkrIRTLbw0dOlQMGTJEODo6ChcXF/H5558XuVzZ5s2bRY0aNYS1tbVq+a2kpCTRpk0bYW9vL7y9vcW8efNEq1atxIgRI4ps/yeffCLeeecdjfKVK1eKxo0biwoVKgh3d3fRsWNHcebMGdX2u3fviuHDh4v69esLBwcHUaFCBREYGCi+/fZbIZfLVfXwzFJhdnZ2onr16qJPnz7i1KlTGsccPHiweP/994tsLxGZJ4kQ/z8znoiICjVhwgRs3LgR8fHxxm6KTlq3bo2goKASTUFblLS0NNSrVw9///03fH19jdIGALh37x5q1aqFkydP6j3Fg4hMH6cWEBGRwXl4eGDp0qVFrm5QGm7cuIEFCxYwiCWyUFy1gIiISsTzN9cZQ0hIyAuXOyMi88WpBURERERklji1gIiIiIjMEgNZIiIiIjJLDGSJiIiIyCwxkCUiIiIis8RAloiIiIjMEgNZIiIiIjJLDGSJiIiIyCwxkCUiIiIis8RAloiIiIjM0v8Bjf1DM4/r0I0AAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "cluster vs rich/poor agreement: 94.4%\n" ] } ], "source": [ "# viz: did the unsupervised split recover anything real? Color by cluster,\n", "# then overlay whether each country is in the top GDP half (a fact k-means never saw).\n", "rich = (df.gdp_per_capita_usd > df.gdp_per_capita_usd.median()).to_numpy()\n", "fig, ax = plt.subplots(figsize=(7, 4))\n", "for c, color in zip((0, 1), (\"#1E40FF\", \"#FF6A00\")):\n", " m = labels == c\n", " ax.scatter(df.gdp_per_capita_usd[m], df.life_satisfaction[m], color=color, label=f\"cluster {c}\")\n", "ax.set_xlabel(\"GDP per capita (USD)\"); ax.set_ylabel(\"life satisfaction\")\n", "ax.set_title(\"k-means clusters (labels were hidden from the algorithm)\")\n", "ax.legend(); plt.tight_layout(); plt.show()\n", "\n", "# Agreement between cluster id and the rich/poor split, max over the two label-orderings\n", "agree = max((labels == rich).mean(), (labels == ~rich).mean())\n", "print(f\"cluster vs rich/poor agreement: {agree:.1%}\")" ] }, { "cell_type": "markdown", "id": "e5c744eb", "metadata": {}, "source": [ "> **Interpretation.** k-means was never told which countries are rich. Yet its two groups line up with the GDP split most of the time, because GDP is the dominant axis of variation. That is what unsupervised learning does: it surfaces structure, and a human decides whether the structure is meaningful. The clusters are not \"right\" or \"wrong\"; they are a hypothesis you then check, here against an external fact.\n" ] }, { "cell_type": "markdown", "id": "16e5bef0", "metadata": {}, "source": [ "### 4.2 Supervised: learn a decision boundary\n", "\n", "Now we add labels. Define \"happy\" as life satisfaction at or above the median, and learn to predict it from two features so the boundary is a drawable line in 2-D. The first feature is the real signal: standardised GDP. The second is a synthetic noise axis we generate with a fixed seed, present only so the plot has two dimensions. We keep it explicit that the second axis carries no information, so you can watch the classifier ignore it.\n" ] }, { "cell_type": "code", "execution_count": 24, "id": "a5b096cc", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.241038Z", "iopub.status.busy": "2026-06-10T18:49:13.240965Z", "iopub.status.idle": "2026-06-10T18:49:13.246534Z", "shell.execute_reply": "2026-06-10T18:49:13.246236Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "happy countries: 21 / 36 (>= median satisfaction)\n", "train accuracy: 86.1%\n" ] } ], "source": [ "# Two features so the boundary is a drawable 2-D line:\n", "# x1 = GDP per capita (standardized), the real signal\n", "# x2 = a synthetic noisy axis (fixed seed), present only to make the plot 2-D and honest\n", "gdp_std = StandardScaler().fit_transform(df[[\"gdp_per_capita_usd\"]]).ravel()\n", "x2 = rng.normal(0, 1, size=len(df)) # synthetic second axis, seeded, no real meaning\n", "F = np.c_[gdp_std, x2] # (n, 2) feature matrix\n", "happy = (df.life_satisfaction >= df.life_satisfaction.median()).astype(int).to_numpy() # the label\n", "print(f\"happy countries: {happy.sum()} / {len(happy)} (>= median satisfaction)\")\n", "\n", "from sklearn.linear_model import LogisticRegression\n", "boundary_clf = LogisticRegression().fit(F, happy)\n", "print(f\"train accuracy: {(boundary_clf.predict(F) == happy).mean():.1%}\")" ] }, { "cell_type": "code", "execution_count": 25, "id": "e75cbb95", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.247581Z", "iopub.status.busy": "2026-06-10T18:49:13.247503Z", "iopub.status.idle": "2026-06-10T18:49:13.317575Z", "shell.execute_reply": "2026-06-10T18:49:13.317221Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# viz: the learned decision boundary as a filled image. Each pixel is colored by\n", "# what the classifier would predict there; the points are the actual countries.\n", "x1g = np.linspace(F[:, 0].min() - 0.5, F[:, 0].max() + 0.5, GRID)\n", "x2g = np.linspace(F[:, 1].min() - 0.5, F[:, 1].max() + 0.5, GRID)\n", "xx, yy = np.meshgrid(x1g, x2g)\n", "zz = boundary_clf.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n", "\n", "fig, ax = plt.subplots(figsize=(7, 4))\n", "ax.contourf(xx, yy, zz, alpha=0.25, levels=1, colors=[\"#1E40FF\", \"#FF6A00\"])\n", "for cls, color, name in ((0, \"#1E40FF\", \"not happy\"), (1, \"#FF6A00\", \"happy\")):\n", " m = happy == cls\n", " ax.scatter(F[m, 0], F[m, 1], color=color, edgecolor=\"k\", label=name)\n", "ax.set_xlabel(\"GDP per capita (standardized)\"); ax.set_ylabel(\"synthetic axis (no meaning)\")\n", "ax.set_title(\"A learned decision boundary\"); ax.legend()\n", "plt.tight_layout(); plt.show()" ] }, { "cell_type": "markdown", "id": "bd22b354", "metadata": {}, "source": [ "> **Interpretation.** The boundary is nearly vertical: the classifier leans almost entirely on GDP and all but ignores the synthetic axis, which carries no signal. That is the supervised story in one image. The model found that one feature predicts the label and the other does not, and it drew the line accordingly. A model-based classifier compresses \"which side of this line\" into a couple of weights.\n" ] }, { "cell_type": "markdown", "id": "caad6393", "metadata": {}, "source": [ "### Exercise 4.1 — Tell supervised from unsupervised from the call signature\n", "`Difficulty 2/5 · ~10 min`\n", "\n", "You will be handed snippets of training code. Write `regime(uses_y, has_reward)` that returns `\"supervised\"`, `\"unsupervised\"`, or `\"reinforcement\"`:\n", "- `\"reinforcement\"` if there is a reward signal (`has_reward` is true),\n", "- else `\"supervised\"` if the fit consumed labels `y` (`uses_y` is true),\n", "- else `\"unsupervised\"`.\n", "Then it is applied to the two models we just built, by inspecting whether each was given a `y`.\n" ] }, { "cell_type": "code", "execution_count": 26, "id": "e7047f47", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.318561Z", "iopub.status.busy": "2026-06-10T18:49:13.318480Z", "iopub.status.idle": "2026-06-10T18:49:13.321716Z", "shell.execute_reply": "2026-06-10T18:49:13.321423Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] 4.1 regime: not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def regime(uses_y, has_reward):\n", " \"\"\"Classify a learning setup from two booleans: did it use labels, is there a reward?\"\"\"\n", " # TODO 1: reward signal wins first -> \"reinforcement\"\n", " # TODO 2: else, if it consumed labels y -> \"supervised\"\n", " # TODO 3: else -> \"unsupervised\"\n", " answer = None\n", " attempted(answer)\n", " return answer\n", "\n", "def _ex41():\n", " assert regime(uses_y=True, has_reward=False) == \"supervised\"\n", " assert regime(uses_y=False, has_reward=False) == \"unsupervised\"\n", " assert regime(uses_y=True, has_reward=True) == \"reinforcement\", \"reward dominates even if labels exist (RLHF)\"\n", " # our two real models: boundary_clf was .fit(F, happy) [labels], km was .fit(feat_s) [no labels]\n", " assert regime(uses_y=True, has_reward=False) == \"supervised\" # the logistic boundary\n", " assert regime(uses_y=False, has_reward=False) == \"unsupervised\" # k-means\n", "\n", "check(\"4.1 regime\", _ex41)" ] }, { "cell_type": "markdown", "id": "d9401b8f", "metadata": {}, "source": [ "
Hint 1 (conceptual)Three branches, checked in priority order: reward, then labels, then neither. RLHF has labels *and* a reward and is still called reinforcement, so reward is checked first.
\n", "\n", "
Hint 2 (pseudocode)\n", "\n", "```python\n", "if has_reward:\n", " answer = \"reinforcement\"\n", "elif uses_y:\n", " answer = \"supervised\"\n", "else:\n", " answer = \"unsupervised\"\n", "```\n", "
\n" ] }, { "cell_type": "code", "execution_count": 27, "id": "822b7e42", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.322556Z", "iopub.status.busy": "2026-06-10T18:49:13.322485Z", "iopub.status.idle": "2026-06-10T18:49:13.324719Z", "shell.execute_reply": "2026-06-10T18:49:13.324272Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] 4.1 regime\n", "logistic boundary (had labels): supervised\n", "k-means (no labels): unsupervised\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines regime; the check below re-verifies it.\n", "def regime(uses_y, has_reward):\n", " if has_reward:\n", " return \"reinforcement\"\n", " if uses_y:\n", " return \"supervised\"\n", " return \"unsupervised\"\n", "\n", "check(\"4.1 regime\", _ex41, required=True)\n", "print(\"logistic boundary (had labels):\", regime(uses_y=True, has_reward=False))\n", "print(\"k-means (no labels): \", regime(uses_y=False, has_reward=False))" ] }, { "cell_type": "markdown", "id": "3fdd412d", "metadata": {}, "source": [ "> **Key takeaways**\n", "> - Unsupervised learning surfaces structure (clusters) you then validate against something external; the clusters are a hypothesis, not an answer.\n", "> - Supervised learning needs labels and produces a decision rule, here a boundary you can draw.\n", "> - A model leans on features that predict the label and ignores those that do not; the near-vertical boundary is that fact made visible.\n", "> - Reinforcement learning is its own regime: reward, not labels, even when labels also exist (RLHF).\n" ] }, { "cell_type": "markdown", "id": "7daf2643", "metadata": {}, "source": [ "## Part 5 — The taxonomy as code\n", "\n", "> **Objectives.** Assemble the chapter into one liftable artifact: a classifier that places any ML problem on the three axes (supervision · batch/online · instance/model) and recommends a starter family, the way the draft's picker does. This is the consolidation cell; the micro-pieces from Parts 1-4 become one function, tested on real problem descriptions.\n", "\n", "The draft's three axes are independent. A problem is some point in supervision × {batch, online} × {instance, model}. We encode the picker as a pure function, test it against a table of worked cases, and finish with an experiment log of everything we measured.\n" ] }, { "cell_type": "markdown", "id": "9af7a226", "metadata": {}, "source": [ "### Exercise 5.1 — The three-axis problem classifier\n", "`Difficulty 3/5 · ~20 min`\n", "\n", "Implement `classify_problem(has_labels, arrival, data_size, feature_type)` returning a dict with keys `supervision`, `learning_mode`, `paradigm`, and `starter`. The rules, straight from the draft's §2-4 and §12 picker:\n", "\n", "- **supervision**: `has_labels` is one of `\"yes\"`, `\"no\"`, `\"some\"`, `\"reward\"` -> `\"supervised\"`, `\"unsupervised\"`, `\"semi-supervised\"`, `\"reinforcement\"`.\n", "- **learning_mode**: `arrival` is `\"batch\"` or `\"streaming\"` -> `\"batch\"` or `\"online\"`.\n", "- **paradigm**: tiny labelled data (`data_size == \"small\"`) is the one place instance-based (k-NN) is the sane default -> `\"instance\"`; otherwise `\"model\"`.\n", "- **starter**: by `feature_type` -> tabular: `\"gradient boosting\"`; image: `\"pretrained CNN\"`; text: `\"pretrained transformer\"`; sequence: `\"gradient boosting on lag features\"`. If there are no labels at all (`has_labels == \"no\"`), the starter is `\"clustering\"` regardless of feature type.\n", "\n", "Harder: add a `confidence` key that is `\"low\"` when `data_size == \"small\"` (the draft's \"more data first\" caveat) and `\"high\"` otherwise.\n" ] }, { "cell_type": "code", "execution_count": 28, "id": "4702639e", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.325717Z", "iopub.status.busy": "2026-06-10T18:49:13.325647Z", "iopub.status.idle": "2026-06-10T18:49:13.330151Z", "shell.execute_reply": "2026-06-10T18:49:13.329806Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] 5.1 classify_problem: not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def classify_problem(has_labels, arrival, data_size, feature_type):\n", " \"\"\"Place an ML problem on the three axes and recommend a starter family.\n", " has_labels: 'yes'|'no'|'some'|'reward'\n", " arrival: 'batch'|'streaming'\n", " data_size: 'small'|'medium'|'large'\n", " feature_type: 'tabular'|'image'|'text'|'sequence'\n", " \"\"\"\n", " SUP = {\"yes\": \"supervised\", \"no\": \"unsupervised\",\n", " \"some\": \"semi-supervised\", \"reward\": \"reinforcement\"}\n", " STARTER = {\"tabular\": \"gradient boosting\", \"image\": \"pretrained CNN\",\n", " \"text\": \"pretrained transformer\", \"sequence\": \"gradient boosting on lag features\"}\n", " # TODO 1: supervision from SUP[has_labels]\n", " supervision = None\n", " # TODO 2: learning_mode -> 'online' if arrival == 'streaming' else 'batch'\n", " learning_mode = None\n", " # TODO 3: paradigm -> 'instance' only when data_size == 'small', else 'model'\n", " paradigm = None\n", " # TODO 4: starter -> 'clustering' if has_labels == 'no', else STARTER[feature_type]\n", " starter = None\n", " attempted(supervision, learning_mode, paradigm, starter)\n", " return {\"supervision\": supervision, \"learning_mode\": learning_mode,\n", " \"paradigm\": paradigm, \"starter\": starter}\n", "\n", "def _ex51():\n", " want4 = {\"supervision\", \"learning_mode\", \"paradigm\", \"starter\"}\n", " # the draft's fraud example: labelled, batch, 10M rows, tabular\n", " fraud = classify_problem(\"yes\", \"batch\", \"large\", \"tabular\")\n", " assert want4 <= set(fraud), f\"missing required keys; got {set(fraud)}\"\n", " assert {k: fraud[k] for k in want4} == {\"supervision\": \"supervised\", \"learning_mode\": \"batch\",\n", " \"paradigm\": \"model\", \"starter\": \"gradient boosting\"}, fraud\n", " # no labels + text -> unsupervised, clustering (draft §12 \"no labels\" row)\n", " noweb = classify_problem(\"no\", \"batch\", \"medium\", \"text\")\n", " assert noweb[\"supervision\"] == \"unsupervised\" and noweb[\"starter\"] == \"clustering\", noweb\n", " # tiny labelled set -> instance-based is the sane default\n", " tiny = classify_problem(\"yes\", \"batch\", \"small\", \"tabular\")\n", " assert tiny[\"paradigm\"] == \"instance\", tiny\n", " # streaming -> online\n", " stream = classify_problem(\"yes\", \"streaming\", \"large\", \"tabular\")\n", " assert stream[\"learning_mode\"] == \"online\", stream\n", " # reward signal -> reinforcement\n", " rl = classify_problem(\"reward\", \"streaming\", \"large\", \"tabular\")\n", " assert rl[\"supervision\"] == \"reinforcement\", rl\n", "\n", "check(\"5.1 classify_problem\", _ex51)" ] }, { "cell_type": "markdown", "id": "2a5b9305", "metadata": {}, "source": [ "
Hint 1 (conceptual)Three of the four outputs are direct lookups or one-line conditionals; the only branch is the starter, which is overridden to `\"clustering\"` whenever there are no labels.
\n", "\n", "
Hint 2 (pseudocode)\n", "\n", "```python\n", "supervision = SUP[has_labels]\n", "learning_mode = \"online\" if arrival == \"streaming\" else \"batch\"\n", "paradigm = \"instance\" if data_size == \"small\" else \"model\"\n", "starter = \"clustering\" if has_labels == \"no\" else STARTER[feature_type]\n", "```\n", "
\n", "\n", "
Help — KeyError on STARTERYou hit `STARTER[feature_type]` before the `has_labels == \"no\"` override. Check the no-labels case first, so an unsupervised problem never indexes the supervised-starter table.
\n" ] }, { "cell_type": "code", "execution_count": 29, "id": "244aed8d", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.331213Z", "iopub.status.busy": "2026-06-10T18:49:13.331132Z", "iopub.status.idle": "2026-06-10T18:49:13.334323Z", "shell.execute_reply": "2026-06-10T18:49:13.333910Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] 5.1 classify_problem\n", "credit-card fraud (10M labelled rows) -> supervised batch model : gradient boosting\n", "cluster customers, no labels -> unsupervised batch model : clustering\n", "recommend on a fast-shifting catalog -> supervised online model : gradient boosting\n", "game-playing agent -> reinforcement online model : gradient boosting\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines classify_problem; the check below re-verifies it.\n", "def classify_problem(has_labels, arrival, data_size, feature_type):\n", " SUP = {\"yes\": \"supervised\", \"no\": \"unsupervised\",\n", " \"some\": \"semi-supervised\", \"reward\": \"reinforcement\"}\n", " STARTER = {\"tabular\": \"gradient boosting\", \"image\": \"pretrained CNN\",\n", " \"text\": \"pretrained transformer\", \"sequence\": \"gradient boosting on lag features\"}\n", " supervision = SUP[has_labels]\n", " learning_mode = \"online\" if arrival == \"streaming\" else \"batch\"\n", " paradigm = \"instance\" if data_size == \"small\" else \"model\"\n", " starter = \"clustering\" if has_labels == \"no\" else STARTER[feature_type]\n", " out = {\"supervision\": supervision, \"learning_mode\": learning_mode,\n", " \"paradigm\": paradigm, \"starter\": starter}\n", " out[\"confidence\"] = \"low\" if data_size == \"small\" else \"high\" # harder goal\n", " return out\n", "\n", "check(\"5.1 classify_problem\", _ex51, required=True)\n", "cases = [\n", " (\"credit-card fraud (10M labelled rows)\", (\"yes\", \"batch\", \"large\", \"tabular\")),\n", " (\"cluster customers, no labels\", (\"no\", \"batch\", \"medium\", \"tabular\")),\n", " (\"recommend on a fast-shifting catalog\", (\"yes\", \"streaming\", \"large\", \"tabular\")),\n", " (\"game-playing agent\", (\"reward\", \"streaming\", \"large\", \"tabular\")),\n", "]\n", "for name, args in cases:\n", " r = classify_problem(*args)\n", " print(f\"{name:40} -> {r['supervision']:14} {r['learning_mode']:6} {r['paradigm']:8} : {r['starter']}\")" ] }, { "cell_type": "markdown", "id": "0d5bd507", "metadata": {}, "source": [ "> **Interpretation.** Four real problems, four different points in the taxonomy, one function. This is the chapter's whole vocabulary made executable: every later chapter is one of these rows expanded into a notebook.\n" ] }, { "cell_type": "markdown", "id": "879bff57", "metadata": {}, "source": [ "### Experiment log\n", "\n", "Everything we measured, as a reference table. If your run lands far from these, something is wrong (re-run from the top; mid-notebook re-runs reproduce because every stochastic cell is seeded).\n", "\n", "| What | Number | Read it as |\n", "|---|---|---|\n", "| baseline (predict the mean) MAE | ~0.50 | the bar every model must beat |\n", "| our least-squares line vs sklearn | match to 1e-6 | the agreement assert passed |\n", "| slice-only line, on its slice | low | the flattering number |\n", "| slice-only line, on dropped countries | much higher | sampling bias, quantified |\n", "| best polynomial degree (by validation) | small (2-4) | the bias-variance sweet spot |\n", "| degree-10 train vs val MAE | ~0 vs blown out | textbook overfitting |\n", "| k-means vs rich/poor agreement | high (~80%+) | GDP dominates the variation |\n", "| logistic boundary train accuracy | high | one feature carries the label |\n", "\n", "> **Key takeaways**\n", "> - The three axes are independent; a problem is a point in their product space.\n", "> - The picker is a decision tree, not a model; every path is a row in the draft's §12 table.\n", "> - The chapter's vocabulary (loss, baseline, train/val, overfit, supervision) survives unchanged into every later chapter.\n" ] }, { "cell_type": "markdown", "id": "15741171", "metadata": {}, "source": [ "## Safety lens\n", "\n", "The three-axis taxonomy is value-neutral; the choices you make along it have safety consequences. Two are worth a runnable look, because they are checks you can paste into any project.\n", "\n", "**Sampling bias is a fairness bug, not only an accuracy bug.** The slice-that-lies in Part 2 is the same mechanism behind a face-recognition system that scores well on the demographic in its training set and fails on the one that was undersampled. The defence is the same: measure error on each subgroup separately, before shipping. The cell below shows the five-line subgroup check the draft recommends, on our own data, split by GDP tier.\n" ] }, { "cell_type": "code", "execution_count": 30, "id": "6e504b73", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.335134Z", "iopub.status.busy": "2026-06-10T18:49:13.335061Z", "iopub.status.idle": "2026-06-10T18:49:13.338497Z", "shell.execute_reply": "2026-06-10T18:49:13.338162Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "poorer half : MAE 0.426 (n=18)\n", "richer half : MAE 0.432 (n=18)\n", "\n", "Aggregate error hides this; per-subgroup error is what you debug from.\n" ] } ], "source": [ "# A subgroup audit: the full-data line's error on poor vs rich countries.\n", "full_line = LinearRegression().fit(X, y)\n", "poor = df.gdp_per_capita_usd <= df.gdp_per_capita_usd.median()\n", "for name, mask in ((\"poorer half\", poor.to_numpy()), (\"richer half\", (~poor).to_numpy())):\n", " sub_mae = P(y[mask], full_line.predict(X[mask]))\n", " print(f\"{name:12}: MAE {sub_mae:.3f} (n={mask.sum()})\")\n", "print(\"\\nAggregate error hides this; per-subgroup error is what you debug from.\")" ] }, { "cell_type": "markdown", "id": "c08124f1", "metadata": {}, "source": [ "> **Interpretation.** A single straight line fits one income band better than the other, because the true curve bends and a line cannot follow both ends. The aggregate MAE averages that disparity away. The habit to carry out of this chapter: report aggregate error to stakeholders, but *debug* from per-subgroup error, every retraining cycle.\n", "\n", "**Online learning can be poisoned continuously.** The 2016 Microsoft Tay chatbot learned online from adversarial input and produced hateful output within 16 hours. The lesson is procedural, not architectural: a system that learns continuously needs a human-in-the-loop gate, update rate limits, and a rollback to a known-good checkpoint. When `classify_problem` returns `learning_mode == \"online\"`, that is your cue to design those three controls in, not bolt them on later.\n" ] }, { "cell_type": "markdown", "id": "757c6a8f", "metadata": {}, "source": [ "## Test yourself\n", "\n", "Three parts: concept self-checks with folded answers, auto-checked problems you implement, and a capstone with a rubric and a folded reference. Every answer is in this notebook; if unsure, re-run that section. Solutions are folded; try before you peek.\n" ] }, { "cell_type": "markdown", "id": "dc09c44c", "metadata": {}, "source": [ "### Part A — Concepts\n", "\n", "1. Name Mitchell's `T`, `P`, and `E` for the GDP model in Part 1.
Answer`T` = predict life satisfaction from GDP per capita; `P` = mean absolute error in satisfaction points (the function `P` we defined); `E` = the table of 36 countries.
\n", "2. In Part 2 the slice-only line had low error on its slice and high error on the dropped countries. Which number is the lie, and why?
AnswerThe low one. It is computed on the very sample that was hand-picked to look linear. Error on data the model did not select (the dropped countries) is the honest estimate.
\n", "3. The degree-10 fit in Part 3 had near-zero training error. Why is that a warning sign, not a success?
AnswerCapacity can always drive training error to zero by memorising. The validation curve turned upward at high degree, the signature of overfitting: the model fit noise, not signal.
\n", "4. Why did we put a `StandardScaler` before `PolynomialFeatures` in the pipeline?
AnswerGDP values in the tens of thousands, raised to the 10th power, overflow into floating-point garbage (~1e48). Scaling to mean 0 / std 1 first keeps the powers numerically stable.
\n", "5. In Part 4, k-means was given no labels yet its clusters matched the rich/poor split ~80% of the time. Did k-means \"know\" about wealth?
AnswerNo. GDP is the largest axis of variation in the standardised features, so the lowest-inertia 2-split falls roughly along it. The match is a property of the data's geometry, not knowledge. A human decides the clusters mean \"rich vs poor\".
\n", "6. The learned decision boundary in Part 4 came out nearly vertical. What does that tell you about the two features?
AnswerThe vertical (GDP) axis carries the signal; the synthetic axis is noise, so the classifier put almost all its weight on GDP and the boundary barely tilts. Models lean on predictive features and ignore useless ones.
\n", "7. Quick task, one line: using the live `df`, compute the fraction of countries with life satisfaction at least 7.0.
Answer`(df.life_satisfaction >= 7.0).mean()`. It is roughly a third; these are the richer European and Anglophone countries.
\n", "8. Why is k-NN called instance-based and linear regression model-based?
Answerk-NN stores the training data and consults it at prediction time (the model *is* the data). Linear regression distils the data into two parameters and discards it (the model is `θ`).
\n", "9. The draft says the test set is \"sacred\". In this notebook we used a train/validation split and tuned degree on validation. Where would a true test set fit?
AnswerA third held-out split, touched once after the degree is locked, to estimate real-world error. Choosing `best_degree` on validation already spends some optimism; the test set is the unspent estimate.
\n", "10. Reinforcement learning has rewards. RLHF on an LLM also has labels (human preferences). Why call it reinforcement and not supervised?
AnswerThe optimisation target is a reward (the preference model's score) maximised over a policy, not a fixed label minimised pointwise. `regime()` checks reward first for exactly this reason.
\n", "11. You read a paper that reports 99% accuracy and nothing else. Name two questions from this chapter that the number cannot answer.
Answer(a) What is the base rate? 99% accuracy is the do-nothing model on a 1%-positive problem. (b) Was it measured on held-out data the model never saw, or leaked? Accuracy without the base rate and the split is uninterpretable.
\n", "12. The agreement assert `check_close(our_line, sklearn_line)` is, in the draft's words, \"the cheapest insurance in the notebook\". Insurance against what?
AnswerAgainst the notebook quietly teaching wrong math. If our hand-rolled least-squares drifted from the library, the cell would halt with a diagnostic instead of printing a plausible-looking but wrong coefficient.
\n" ] }, { "cell_type": "markdown", "id": "c2f94ed9", "metadata": {}, "source": [ "### Part B — Auto-checked problems\n", "\n", "**Problem B1 — R² from scratch** · `Difficulty 2/5 · ~10 min`\n", "\n", "The draft lists R² as the normalized regression metric: 1 for a perfect fit, 0 for a constant-mean predictor, negative for worse-than-mean. Implement `r2(y_true, y_pred)` = `1 - SS_res / SS_tot`, where `SS_res = sum((y - ŷ)²)` and `SS_tot = sum((y - mean(y))²)`. No sklearn in your body; the check compares against sklearn's `r2_score`.\n" ] }, { "cell_type": "code", "execution_count": 31, "id": "f3d2e269", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.339230Z", "iopub.status.busy": "2026-06-10T18:49:13.339150Z", "iopub.status.idle": "2026-06-10T18:49:13.343086Z", "shell.execute_reply": "2026-06-10T18:49:13.342737Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] B1 r2 from scratch: not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def r2(y_true, y_pred):\n", " \"\"\"Coefficient of determination, from scratch.\"\"\"\n", " y_true, y_pred = np.asarray(y_true, float), np.asarray(y_pred, float)\n", " # TODO 1: ss_res = sum of squared residuals (y_true - y_pred)\n", " ss_res = None\n", " # TODO 2: ss_tot = sum of squared deviations from the mean of y_true\n", " ss_tot = None\n", " attempted(ss_res, ss_tot)\n", " return 1.0 - ss_res / ss_tot\n", "\n", "def _b1():\n", " from sklearn.metrics import r2_score\n", " preds = LinearRegression().fit(X, y).predict(X)\n", " check_close(r2(y, preds), r2_score(y, preds), atol=1e-9,\n", " msg=\"your R^2 should match sklearn's r2_score exactly\")\n", " # the constant-mean predictor scores exactly 0 by construction\n", " check_close(r2(y, np.full_like(y, y.mean())), 0.0, atol=1e-9,\n", " msg=\"predicting the mean must give R^2 = 0\")\n", "\n", "check(\"B1 r2 from scratch\", _b1)" ] }, { "cell_type": "markdown", "id": "b45293b4", "metadata": {}, "source": [ "
Hint 1 (conceptual)Both pieces are `np.sum((... )**2)`. The numerator uses residuals; the denominator uses deviations from `y_true.mean()`.
\n", "
Hint 2 (pseudocode)\n", "\n", "```python\n", "ss_res = np.sum((y_true - y_pred) ** 2)\n", "ss_tot = np.sum((y_true - y_true.mean()) ** 2)\n", "```\n", "
\n" ] }, { "cell_type": "code", "execution_count": 32, "id": "f44a2d05", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.343864Z", "iopub.status.busy": "2026-06-10T18:49:13.343793Z", "iopub.status.idle": "2026-06-10T18:49:13.347031Z", "shell.execute_reply": "2026-06-10T18:49:13.346765Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] B1 r2 from scratch\n", "line R^2 on all countries: 0.505\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines r2; the check below re-verifies it.\n", "def r2(y_true, y_pred):\n", " y_true, y_pred = np.asarray(y_true, float), np.asarray(y_pred, float)\n", " ss_res = np.sum((y_true - y_pred) ** 2)\n", " ss_tot = np.sum((y_true - y_true.mean()) ** 2)\n", " return 1.0 - ss_res / ss_tot\n", "\n", "check(\"B1 r2 from scratch\", _b1, required=True)\n", "print(f\"line R^2 on all countries: {r2(y, LinearRegression().fit(X, y).predict(X)):.3f}\")" ] }, { "cell_type": "markdown", "id": "96b16243", "metadata": {}, "source": [ "**Problem B2 — A leak-free three-way split** · `Difficulty 3/5 · ~15 min`\n", "\n", "The draft's §6-7 insist: fit preprocessing on train only, and the test set is held out, touched once. Implement `split_and_scale(X, y, seed)` that returns `(Xtr_s, Xva_s, Xte_s, ytr, yva, yte)` for a 60/20/20 split, with a `StandardScaler` **fit on the training fold only** and applied to all three. The check verifies the sizes and that the scaler did not peek at validation/test (their post-scaling means are not forced to zero).\n" ] }, { "cell_type": "code", "execution_count": 33, "id": "136ae3ea", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.347969Z", "iopub.status.busy": "2026-06-10T18:49:13.347898Z", "iopub.status.idle": "2026-06-10T18:49:13.351761Z", "shell.execute_reply": "2026-06-10T18:49:13.351384Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] B2 leak-free split: not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def split_and_scale(Xin, yin, seed=SEED):\n", " \"\"\"60/20/20 split with a scaler fit on train only. Returns six arrays.\"\"\"\n", " from sklearn.model_selection import train_test_split\n", " from sklearn.preprocessing import StandardScaler\n", " # TODO 1: split off 20% as test (random_state=seed)\n", " Xtr_full, Xte, ytr_full, yte = None, None, None, None\n", " # TODO 2: from the remaining 80%, split off 25% as validation (-> 20% of the whole)\n", " Xtr, Xva, ytr, yva = None, None, None, None\n", " # TODO 3: fit a StandardScaler on Xtr ONLY, then transform all three\n", " scaler = None\n", " attempted(Xtr_full, Xte, Xtr, Xva, scaler)\n", " Xtr_s, Xva_s, Xte_s = scaler.transform(Xtr), scaler.transform(Xva), scaler.transform(Xte)\n", " return Xtr_s, Xva_s, Xte_s, ytr, yva, yte\n", "\n", "def _b2():\n", " Xtr_s, Xva_s, Xte_s, ytr, yva, yte = split_and_scale(X, y)\n", " n = len(X)\n", " assert len(Xtr_s) + len(Xva_s) + len(Xte_s) == n, \"splits must cover every row exactly once\"\n", " assert abs(len(Xte_s) - 0.2 * n) <= 1, f\"test fold should be ~20% of {n}, got {len(Xte_s)}\"\n", " # train mean is forced to ~0 by its own scaler; val/test are NOT, because the scaler never saw them\n", " assert abs(Xtr_s.mean()) < 1e-9, \"train fold should be centered by its own scaler\"\n", " assert abs(Xva_s.mean()) > 1e-9, \"validation mean must NOT be exactly 0; the scaler fit on train only\"\n", "\n", "check(\"B2 leak-free split\", _b2)" ] }, { "cell_type": "markdown", "id": "fb7dbc3a", "metadata": {}, "source": [ "
Hint 1 (conceptual)Two nested `train_test_split` calls. To carve 20% val out of the remaining 80%, the inner `test_size` is `0.25` (because 0.25 × 0.8 = 0.2).
\n", "
Hint 2 (pseudocode)\n", "\n", "```python\n", "Xtr_full, Xte, ytr_full, yte = train_test_split(Xin, yin, test_size=0.2, random_state=seed)\n", "Xtr, Xva, ytr, yva = train_test_split(Xtr_full, ytr_full, test_size=0.25, random_state=seed)\n", "scaler = StandardScaler().fit(Xtr)\n", "```\n", "
\n", "
Help — \"validation mean must NOT be exactly 0\" assert firesYou fit the scaler on the whole feature matrix, or on the validation fold. Fit on `Xtr` only; the val/test means come out near but not exactly zero precisely because the scaler never saw them.
\n" ] }, { "cell_type": "code", "execution_count": 34, "id": "f76e37ab", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.352707Z", "iopub.status.busy": "2026-06-10T18:49:13.352635Z", "iopub.status.idle": "2026-06-10T18:49:13.357380Z", "shell.execute_reply": "2026-06-10T18:49:13.357012Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] B2 leak-free split\n", "sizes: train 21 · val 7 · test 8\n", "train mean 0.00e+00 (≈0) · val mean -0.101 (not 0, no leak)\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines split_and_scale; the check below re-verifies it.\n", "def split_and_scale(Xin, yin, seed=SEED):\n", " from sklearn.model_selection import train_test_split\n", " from sklearn.preprocessing import StandardScaler\n", " Xtr_full, Xte, ytr_full, yte = train_test_split(Xin, yin, test_size=0.2, random_state=seed)\n", " Xtr, Xva, ytr, yva = train_test_split(Xtr_full, ytr_full, test_size=0.25, random_state=seed)\n", " scaler = StandardScaler().fit(Xtr)\n", " Xtr_s, Xva_s, Xte_s = scaler.transform(Xtr), scaler.transform(Xva), scaler.transform(Xte)\n", " return Xtr_s, Xva_s, Xte_s, ytr, yva, yte\n", "\n", "check(\"B2 leak-free split\", _b2, required=True)\n", "Xtr_s, Xva_s, Xte_s, *_ = split_and_scale(X, y)\n", "print(f\"sizes: train {len(Xtr_s)} · val {len(Xva_s)} · test {len(Xte_s)}\")\n", "print(f\"train mean {Xtr_s.mean():.2e} (≈0) · val mean {Xva_s.mean():.3f} (not 0, no leak)\")" ] }, { "cell_type": "markdown", "id": "98f2ebcb", "metadata": {}, "source": [ "**Problem B3 — The accuracy a base rate buys for free** · `Difficulty 1/5 · ~6 min`\n", "\n", "The draft warns that accuracy lies under class imbalance: predicting the majority class always yields the majority's base rate. Implement `majority_baseline_accuracy(labels)` returning the accuracy of always predicting the most common label. No model, no sklearn.\n" ] }, { "cell_type": "code", "execution_count": 35, "id": "7416de21", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.358433Z", "iopub.status.busy": "2026-06-10T18:49:13.358337Z", "iopub.status.idle": "2026-06-10T18:49:13.362043Z", "shell.execute_reply": "2026-06-10T18:49:13.361725Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -- ] B3 majority baseline: not attempted yet — fill in the TODO above, then re-run.\n" ] }, { "data": { "text/plain": [ "False" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def majority_baseline_accuracy(labels):\n", " \"\"\"Accuracy of always predicting the single most frequent label.\"\"\"\n", " labels = np.asarray(labels)\n", " # TODO 1: count each label, take the largest count, divide by the total\n", " acc = None\n", " attempted(acc)\n", " return float(acc)\n", "\n", "def _b3():\n", " # 90 zeros, 10 ones -> always-predict-0 scores 0.90\n", " y_imbal = np.array([0] * 90 + [1] * 10)\n", " check_close(majority_baseline_accuracy(y_imbal), 0.90, atol=1e-9,\n", " msg=\"90/100 majority -> 0.90 with zero learning; this is the accuracy trap\")\n", " # on our happy/not-happy label it equals the larger class fraction\n", " h = (df.life_satisfaction >= df.life_satisfaction.median()).astype(int).to_numpy()\n", " expect = max(np.bincount(h)) / len(h)\n", " check_close(majority_baseline_accuracy(h), expect, atol=1e-9)\n", "\n", "check(\"B3 majority baseline\", _b3)" ] }, { "cell_type": "markdown", "id": "9af37fb2", "metadata": {}, "source": [ "
Hint 1 (conceptual)`np.bincount` gives counts per label; the baseline accuracy is `max(counts) / counts.sum()`.
\n", "
Solution\n", "\n", "```python\n", "def majority_baseline_accuracy(labels):\n", " labels = np.asarray(labels)\n", " counts = np.bincount(labels)\n", " return float(counts.max() / counts.sum())\n", "```\n", "
\n" ] }, { "cell_type": "code", "execution_count": 36, "id": "595e5827", "metadata": { "execution": { "iopub.execute_input": "2026-06-10T18:49:13.362907Z", "iopub.status.busy": "2026-06-10T18:49:13.362823Z", "iopub.status.idle": "2026-06-10T18:49:13.365690Z", "shell.execute_reply": "2026-06-10T18:49:13.365288Z" }, "collapsed": true, "jupyter": { "source_hidden": true }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ ok ] B3 majority baseline\n", "On a 90/10 split, doing nothing scores 90%\n" ] } ], "source": [ "#@title Solution { display-mode: \"form\" }\n", "# solution: redefines majority_baseline_accuracy; the check below re-verifies it.\n", "def majority_baseline_accuracy(labels):\n", " labels = np.asarray(labels)\n", " counts = np.bincount(labels)\n", " return float(counts.max() / counts.sum())\n", "\n", "check(\"B3 majority baseline\", _b3, required=True)\n", "print(\"On a 90/10 split, doing nothing scores\", f\"{majority_baseline_accuracy(np.array([0]*90+[1]*10)):.0%}\")" ] }, { "cell_type": "markdown", "id": "7d160ecb", "metadata": {}, "source": [ "### Part C — Capstone: the full sampling-bias and bias-variance story, end to end\n", "\n", "One project that threads the whole chapter. Redo the reveal on a dataset *you* sample badly on purpose, then fix it.\n", "\n", "**Deliverables**\n", "1. Take the full `df`. Carve a biased sample by some rule of your choosing (e.g. only countries with satisfaction in `[6.0, 7.2]`, or only a single continent if you add that column). State the rule in a comment.\n", "2. Fit a line on the biased sample and report its MAE on the sample vs on the dropped countries (reuse `P` and the Part 2 pattern). Show the gap.\n", "3. Sweep polynomial degree on a *fair* train/validation split of the full data (reuse the Part 3 loop) and report the validation-selected degree and its MAE.\n", "4. Run the per-subgroup audit from the Safety lens on your final model and state whether the error is balanced across the GDP halves.\n", "\n", "**Self-assessment** (pass / partial / fail):\n", "- (a) the biased-sample line looks better on its sample than on the dropped countries (the gap reproduces);\n", "- (b) the fair sweep produces a U-shaped validation curve with a low-degree minimum, not degree 10;\n", "- (c) you touch a held-out fold exactly once for your final reported number;\n", "- (d) your subgroup audit reports two numbers and you say in one sentence whether they are balanced;\n", "- (e) the whole thing runs top-to-bottom with no manual edits.\n", "\n", "
My solution (reference, runs in seconds)\n", "\n", "```python\n", "# 1. biased sample: keep only the \"comfortable middle\" of satisfaction\n", "bias_rule = (df.life_satisfaction >= 6.0) & (df.life_satisfaction <= 7.2)\n", "db, dr = df[bias_rule], df[~bias_rule]\n", "Xb = db[[\"gdp_per_capita_usd\"]].to_numpy(float); yb = db.life_satisfaction.to_numpy(float)\n", "\n", "# 2. the gap\n", "lb = LinearRegression().fit(Xb, yb)\n", "print(f\"biased line on its sample : {P(yb, lb.predict(Xb)):.3f}\")\n", "print(f\"biased line on dropped : {P(dr.life_satisfaction, lb.predict(dr[['gdp_per_capita_usd']])):.3f}\")\n", "\n", "# 3. fair sweep on the full data\n", "Xtr, Xva, ytr, yva = train_test_split(X, y, test_size=0.35, random_state=SEED)\n", "ve = [P(yva, poly_model(d).fit(Xtr, ytr).predict(Xva)) for d in range(1, 11)]\n", "best = int(np.argmin(ve)) + 1\n", "print(f\"fair sweep best degree: {best} (val MAE {min(ve):.3f})\")\n", "\n", "# 4. subgroup audit on the final (fair) model\n", "final = poly_model(best).fit(Xtr, ytr)\n", "poor = df.gdp_per_capita_usd <= df.gdp_per_capita_usd.median()\n", "for nm, mk in ((\"poorer\", poor.to_numpy()), (\"richer\", (~poor).to_numpy())):\n", " print(f\"{nm}: MAE {P(y[mk], final.predict(X[mk])):.3f}\")\n", "```\n", "\n", "The lesson lands when (b) picks a low degree and (a) shows the biased line's gap: capacity and sampling are two different failure axes, and a fair split plus a representative sample is the fix for each.
\n" ] }, { "cell_type": "markdown", "id": "95cc4d3a", "metadata": {}, "source": [ "## Reflection\n", "\n", "Write ~150 words, for yourself, in the cell below. Nobody grades it; writing it is the point. What was the dumbest bug you hit in this notebook, and how did you find it? A strong candidate: forgetting that the slice-only line's low error was measured on the slice, and being briefly convinced the model was good. Or the degree-10 fit that looked perfect until the validation number appeared. Name the moment you almost believed a flattering number, and the single check that disabused you. The skill this chapter teaches is not the taxonomy; it is the reflex to distrust a result computed on the data you chose, and to reach for the held-out number instead. Writing down where that reflex failed you today is how it becomes automatic.\n" ] }, { "cell_type": "markdown", "id": "0fe57066", "metadata": {}, "source": [ "*(Your reflection here. Double-click to edit.)*\n" ] }, { "cell_type": "markdown", "id": "94980c78", "metadata": {}, "source": [ "## Going further\n", "\n", "- Aurélien Géron, *Hands-On ML* 3e, Ch 1 — the source of the lifesat reveal and the three-axis taxonomy. Read it once after this notebook.\n", "- *fast.ai* book, Ch 1 (`fastbook/01_intro`) — the Arthur-Samuel framing and \"deep learning is not magic\" argument; a useful contrast to Géron's mathematical angle.\n", "- scikit-learn user guide, *Underfitting vs. Overfitting* — the polynomial-degree demo this part is built on, with the same U-curve.\n", "- Tom Mitchell, *Machine Learning* (1997), Ch 1 — the original `T`/`P`/`E` definition.\n", "- Andrew Ng / Afshine Amidi, *CS229 supervised-learning cheat sheet* — the two-page algorithm picker behind Part 5.\n", "\n", "## What this enables\n", "\n", "- **Ch 02 — End-to-End ML Project**: you ran the bias / overfit reveals on 36 rows; Ch 02 runs the full eight-step workflow on real California housing, with the stratified split and bootstrap confidence intervals this notebook only gestured at.\n", "- **Ch 03 — Classification**: the decision boundary and the majority-baseline trap (Problem B3) open up into the full confusion matrix, precision/recall, and ROC/PR curves.\n", "- **Ch 04 — Training Models**: the least-squares line we solved in closed form gets re-derived as gradient descent on a loss, the move that scales from this line all the way to neural networks.\n", "- The gap this notebook leaves: we picked degree on a single validation split, which is noisy on 36 rows. Ch 02 replaces it with k-fold cross-validation, the honest small-data answer.\n" ] }, { "cell_type": "markdown", "id": "8d81d274", "metadata": {}, "source": [ "---\n", "*Built top-to-bottom. If every check above printed `[ ok ]`, you've reproduced the chapter. Total running time and last-verified date written by CI.*\n" ] } ], "metadata": { "kernelspec": { "display_name": "obvix-nb", "language": "python", "name": "obvix-nb" }, "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.10.12" }, "obvix": { "title": "Ch 01 — The ML Landscape" } }, "nbformat": 4, "nbformat_minor": 5 }