From ac4d2afed49ef02c56c3dfe5ca68f23b28cb0c56 Mon Sep 17 00:00:00 2001 From: hansp Date: Thu, 8 Oct 2026 16:46:27 -0400 Subject: [PATCH] Updated README.md, few bug tweaks, adding regression_results.ipynb --- README.md | 47 +- api/app/data_setup.py | 2 +- api/app/museum_api.py | 10 +- docker-compose.yaml | 5 +- notebooks/Dockerfile | 2 +- notebooks/regression_results.ipynb | 853 +++++++++++++++++++++++++ notebooks/work/museum_regression.ipynb | 313 --------- 7 files changed, 886 insertions(+), 346 deletions(-) create mode 100644 notebooks/regression_results.ipynb delete mode 100644 notebooks/work/museum_regression.ipynb diff --git a/README.md b/README.md index 9a8f5ac..c1bcc69 100644 --- a/README.md +++ b/README.md @@ -1,30 +1,37 @@ # Museum Analytics # -## ⚙️ Configuration Setup - -This project uses environment variables to secure sensitive information. Follow these steps to configure your local environment: - -1. **Duplicate the template file:** - Copy the `.env.example` file and rename it to `.env` in the root directory. - ```bash - cp .env.example .env - ``` -2. **Update your keys:** - Open the newly created `.env` file in your text editor and replace the placeholder values with your actual credentials: - ```text - WIKIPEDIA_USER_AGENT="MuseumAnalytics/0.1 (your_email_address)" - ``` -⚠️ **Important:** Never commit your `.env` file to Git. It is already added to `.gitignore` to protect your secrets. - -## Installation +## Installation and how to use 1. **Make sure docker is installed: see https://docs.docker.com/get-started/get-docker/ for instructions.** + 2. **Clone the repo** ```Bash git clone https://git.hanspayer.com/hpayer/museum_analytics.git ``` -3. Build and start the museum analytics server with docker: +3. **Duplicate the template file:** + Copy the `.env.example` file and rename it to `.env` in the root directory. + ```bash + cd museum_analytics + cp ./api/app/.env.example ./api/app/.env + ``` +4. **Modify .env** + Open the newly created `.env` file in your text editor and replace the placeholder values with your actual credentials: + ```text + WIKIPEDIA_USER_AGENT="MuseumAnalytics/0.1 (your_email_address)" + ``` + ⚠️ **Important:** Never commit your `.env` file to Git. It is already added to `.gitignore` to protect your secrets. + + +5. **Build and start the museum analytics and jupyter notebook servers with docker compose:** ```Bash - cd ./api - docker build --network=host --no-cache -t museum-analytics-server . + # in the museum_analytics working directory + docker compose up --build + ``` +6. **Open the http://127.0.0.1:8888/ in your browser to access jupyter notebook.** + +7. **Open the regression_results.ipynb file and Run the code in jupyter notebook.** + +8. **To shutdown the servers, run this command in the terminal** + ```Bash + docker compose down ``` \ No newline at end of file diff --git a/api/app/data_setup.py b/api/app/data_setup.py index cbd6beb..799719b 100644 --- a/api/app/data_setup.py +++ b/api/app/data_setup.py @@ -7,7 +7,7 @@ import pandas as pd load_dotenv() -WIKIPEDIA_USER_AGENT = os.getenv("WIKIPEDIA_USER_AGENT") +WIKIPEDIA_USER_AGENT: str = os.getenv("WIKIPEDIA_USER_AGENT", "MuseumAnalytics/0.1 (johndoe@gmail.com)") class TableNotFound(Exception): diff --git a/api/app/museum_api.py b/api/app/museum_api.py index ec3046b..cb91802 100644 --- a/api/app/museum_api.py +++ b/api/app/museum_api.py @@ -8,14 +8,6 @@ Run locally (from the repo root): or run this file directly (e.g. from the IDE): python api/museum_api.py - -Or with a DataFrame you already have in memory: - - from api.museum_api import create_app - import uvicorn - uvicorn.run(create_app(df), port=8000) - -Expected columns: Name, Visitors, City, Country, Population """ from __future__ import annotations @@ -252,7 +244,7 @@ def create_app( return [Prediction(population=p, predicted_visitors=float(v)) for p, v in zip(req.populations, preds)] - @app.get("data") + @app.get("/data") def data(): """Every row the model was fitted on, with its prediction.""" m = get_model() diff --git a/docker-compose.yaml b/docker-compose.yaml index 4667a3d..f6a97c1 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -15,8 +15,9 @@ services: ports: - "8888:8888" environment: - - FASTAPI_URL=http://localhost:8000 + - MUSEUM_ANALYTICS_URL=http://museum_analytics_app:8000 + depends_on: - museum_analytics_app volumes: - - ./notebooks:/home/jovyan/work \ No newline at end of file + - ./notebooks:/workspace \ No newline at end of file diff --git a/notebooks/Dockerfile b/notebooks/Dockerfile index 66b8e4e..a8f420d 100644 --- a/notebooks/Dockerfile +++ b/notebooks/Dockerfile @@ -23,4 +23,4 @@ COPY . /workspace EXPOSE 8888 -CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--NotebookApp.token=''"] \ No newline at end of file +CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--ServerApp.token=", "--ServerApp.password=", "--ServerApp.custom_display_url=http://localhost:8888"] \ No newline at end of file diff --git a/notebooks/regression_results.ipynb b/notebooks/regression_results.ipynb new file mode 100644 index 0000000..960e941 --- /dev/null +++ b/notebooks/regression_results.ipynb @@ -0,0 +1,853 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-00", + "metadata": {}, + "source": [ + "# Museum regression results\n", + "\n", + "A read-only report on the regression model that the `museum_analytics` FastAPI server has loaded.\n", + "Everything here comes from the API over HTTP. The notebook never calls `/train`, so it shows the\n", + "model the server built from its own data at startup and leaves it unchanged.\n", + "\n", + "| Endpoint | Used for |\n", + "|---|---|\n", + "| `GET /health` | check the server is up and has a model |\n", + "| `GET /model` | fit statistics and the fitted equation |\n", + "| `GET /data` | every museum the model was fitted on, with its prediction |\n", + "| `POST /predict` | the fitted curve, and predictions for new cities |\n", + "| `GET /residuals` | museums that most beat or miss what their city size predicts |" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-01", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import requests\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import FuncFormatter, LogLocator, NullFormatter\n", + "\n", + "# Inside docker-compose this is http://museum_analytics_app:8000; outside it, localhost.\n", + "API = os.getenv(\"MUSEUM_ANALYTICS_URL\", \"http://localhost:8000\")\n", + "\n", + "\n", + "def get(path, **params):\n", + " r = requests.get(f\"{API}{path}\", params=params, timeout=10)\n", + " r.raise_for_status()\n", + " return r.json()\n", + "\n", + "\n", + "def post(path, payload):\n", + " r = requests.post(f\"{API}{path}\", json=payload, timeout=10)\n", + " r.raise_for_status()\n", + " return r.json()\n", + "\n", + "\n", + "BLUE, ORANGE, INK, MUTED, GRID = \"#2a78d6\", \"#eb6834\", \"#0b0b0b\", \"#52514e\", \"#e6e5e0\"\n", + "plt.rcParams.update({\n", + " \"axes.spines.top\": False, \"axes.spines.right\": False,\n", + " \"axes.edgecolor\": MUTED, \"axes.labelcolor\": INK, \"axes.titlecolor\": INK,\n", + " \"xtick.color\": MUTED, \"ytick.color\": MUTED,\n", + " \"axes.grid\": True, \"axes.axisbelow\": True, \"grid.color\": GRID, \"grid.linewidth\": 0.8,\n", + " \"legend.frameon\": False, \"figure.dpi\": 110,\n", + "})\n", + "\n", + "\n", + "def human(x, _=None):\n", + " \"\"\"1_500_000 -> '1.5M'\"\"\"\n", + " for div, suf in ((1e9, \"B\"), (1e6, \"M\"), (1e3, \"K\")):\n", + " if abs(x) >= div:\n", + " return f\"{x / div:.3g}{suf}\"\n", + " return f\"{x:.3g}\"\n", + "\n", + "\n", + "def human_axes(ax, log=False):\n", + " \"\"\"Readable tick labels; on log axes tick at 1, 2, 5 x 10^k.\"\"\"\n", + " for axis in (ax.xaxis, ax.yaxis):\n", + " if log:\n", + " axis.set_major_locator(LogLocator(base=10, subs=(1, 2, 5)))\n", + " axis.set_minor_formatter(NullFormatter())\n", + " axis.set_major_formatter(FuncFormatter(human))" + ] + }, + { + "cell_type": "markdown", + "id": "cell-02", + "metadata": {}, + "source": [ + "## 1. Check the server" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-03", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'status': 'ok', 'model_loaded': True}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "try:\n", + " health = get(\"/health\")\n", + "except requests.ConnectionError:\n", + " raise SystemExit(f\"Can't reach the API at {API}. Start it with: docker compose up --build -d\")\n", + "\n", + "if not health[\"model_loaded\"]:\n", + " raise SystemExit(\"The server is up but has no model loaded. POST /train first.\")\n", + "health" + ] + }, + { + "cell_type": "markdown", + "id": "cell-04", + "metadata": {}, + "source": [ + "## 2. Model summary\n", + "\n", + "`GET /model` returns the fit statistics. With the default `log` scale the model is\n", + "log10(visitors) ~ log10(population), so the slope is an elasticity: how visitors scale with city size." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cell-05", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "visitors = 338,577.3 * population^0.128\n", + "A 10x larger city is associated with 1.34x the visitors.\n", + "\n", + "Caution: city population explains only about 2% of the variation in visitors, so treat predictions as rough baselines.\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuemeaning
n71rows fitted
scalelogaxis transform
aggregate_by_cityFalseone row per city?
slope0.128263change in (log) visitors per unit of (log) pop...
intercept5.529658fitted intercept
R²0.084989share of variance explained (training data)
CV R²0.016122R² on held-out folds (5-fold CV)
Pearson r0.291528linear correlation
Spearman ρ0.331742rank correlation
\n", + "
" + ], + "text/plain": [ + " value meaning\n", + "n 71 rows fitted\n", + "scale log axis transform\n", + "aggregate_by_city False one row per city?\n", + "slope 0.128263 change in (log) visitors per unit of (log) pop...\n", + "intercept 5.529658 fitted intercept\n", + "R² 0.084989 share of variance explained (training data)\n", + "CV R² 0.016122 R² on held-out folds (5-fold CV)\n", + "Pearson r 0.291528 linear correlation\n", + "Spearman ρ 0.331742 rank correlation" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary = get(\"/model\")\n", + "is_log = summary[\"scale\"] == \"log\"\n", + "\n", + "stats = pd.DataFrame({\n", + " \"value\": [summary[\"n_samples\"], summary[\"scale\"], summary[\"aggregate_by_city\"],\n", + " summary[\"slope\"], summary[\"intercept\"], summary[\"r2\"],\n", + " summary[\"cv_r2_5fold\"], summary[\"pearson_r\"], summary[\"spearman_rho\"]],\n", + " \"meaning\": [\"rows fitted\", \"axis transform\", \"one row per city?\",\n", + " \"change in (log) visitors per unit of (log) population\", \"fitted intercept\",\n", + " \"share of variance explained (training data)\",\n", + " \"R² on held-out folds (5-fold CV)\",\n", + " \"linear correlation\", \"rank correlation\"],\n", + "}, index=[\"n\", \"scale\", \"aggregate_by_city\", \"slope\", \"intercept\", \"R²\",\n", + " \"CV R²\", \"Pearson r\", \"Spearman ρ\"])\n", + "\n", + "print(summary[\"equation\"])\n", + "print(summary[\"interpretation\"])\n", + "fit = summary[\"cv_r2_5fold\"] if summary[\"cv_r2_5fold\"] is not None else summary[\"r2\"]\n", + "if fit < 0.3:\n", + " print(f\"\\nCaution: city population explains only about {max(fit, 0):.0%} of the variation in \"\n", + " \"visitors, so treat predictions as rough baselines.\")\n", + "stats" + ] + }, + { + "cell_type": "markdown", + "id": "cell-06", + "metadata": {}, + "source": [ + "## 3. The fitted line\n", + "\n", + "Each dot is a museum. The line is drawn by sending a grid of populations to `POST /predict`, so it\n", + "is exactly what the server would answer. The five museums furthest from the line are labelled." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cell-07", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "points = pd.DataFrame(get(\"/data\"))\n", + "\n", + "grid = (np.geomspace if is_log else np.linspace)(points.Population.min(), points.Population.max(), 200)\n", + "curve = pd.DataFrame(post(\"/predict\", {\"populations\": grid.tolist()}))\n", + "\n", + "# Residual on the scale the model was fitted on\n", + "if is_log:\n", + " points[\"residual\"] = np.log10(points.Visitors / points.Predicted)\n", + "else:\n", + " points[\"residual\"] = points.Visitors - points.Predicted\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 6))\n", + "ax.scatter(points.Population, points.Visitors, s=40, color=BLUE, alpha=0.75,\n", + " edgecolor=\"white\", linewidth=1, label=\"Museum\", zorder=3)\n", + "ax.plot(curve.population, curve.predicted_visitors, color=ORANGE, lw=2,\n", + " label=f\"Fit: {summary['equation']}\", zorder=4)\n", + "\n", + "for _, r in points.loc[points.residual.abs().nlargest(5).index].iterrows():\n", + " ax.annotate(r.Name, (r.Population, r.Visitors), xytext=(6, 4),\n", + " textcoords=\"offset points\", fontsize=8, color=MUTED)\n", + "\n", + "if is_log:\n", + " ax.set_xscale(\"log\")\n", + " ax.set_yscale(\"log\")\n", + "human_axes(ax, is_log)\n", + "ax.set_xlabel(\"City population\")\n", + "ax.set_ylabel(\"Annual visitors\")\n", + "cv = summary[\"cv_r2_5fold\"]\n", + "ax.set_title(f\"Visitors vs. city population R² = {summary['r2']:.2f}\"\n", + " + (f\" (cross-validated {cv:.2f})\" if cv is not None else \"\"),\n", + " loc=\"left\", fontsize=12)\n", + "ax.legend(loc=\"upper left\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-08", + "metadata": {}, + "source": [ + "## 4. How good are the predictions?\n", + "\n", + "Left: actual vs. predicted visitors. Points on the dashed line are predicted perfectly; above it the\n", + "museum beats its prediction. Right: the spread of residuals. A narrow, centred spread means city size\n", + "explains a lot; a wide one means other factors matter more." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cell-09", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "82% of museums are within 2× of their predicted visitors.\n" + ] + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + "ax1.scatter(points.Predicted, points.Visitors, s=40, color=BLUE, alpha=0.75,\n", + " edgecolor=\"white\", linewidth=1, zorder=3)\n", + "lo = min(points.Predicted.min(), points.Visitors.min()) * 0.9\n", + "hi = max(points.Predicted.max(), points.Visitors.max()) * 1.1\n", + "ax1.plot([lo, hi], [lo, hi], color=MUTED, lw=1, ls=\"--\", label=\"Perfect prediction\")\n", + "if is_log:\n", + " ax1.set_xscale(\"log\")\n", + " ax1.set_yscale(\"log\")\n", + "ax1.set_xlim(lo, hi) # same range on both axes so the diagonal is a true 45° line\n", + "ax1.set_ylim(lo, hi)\n", + "ax1.set_aspect(\"equal\")\n", + "human_axes(ax1, is_log)\n", + "ax1.set_xlabel(\"Predicted visitors\")\n", + "ax1.set_ylabel(\"Actual visitors\")\n", + "ax1.set_title(\"Actual vs. predicted\", loc=\"left\", fontsize=12)\n", + "ax1.legend(loc=\"lower right\")\n", + "\n", + "ax2.hist(points.residual, bins=20, color=BLUE, edgecolor=\"white\", linewidth=2)\n", + "ax2.axvline(0, color=MUTED, lw=1)\n", + "if is_log:\n", + " ticks = np.array([0.1, 0.2, 0.5, 1, 2, 5, 10])\n", + " ticks = ticks[(np.log10(ticks) >= points.residual.min() - 0.1) &\n", + " (np.log10(ticks) <= points.residual.max() + 0.1)]\n", + " ax2.set_xticks(np.log10(ticks), [f\"{t:g}×\" for t in ticks])\n", + " ax2.set_xlabel(\"Actual ÷ predicted visitors (log scale)\")\n", + "else:\n", + " ax2.xaxis.set_major_formatter(FuncFormatter(human))\n", + " ax2.set_xlabel(\"Actual − predicted visitors\")\n", + "ax2.set_ylabel(\"Museums\")\n", + "ax2.set_title(\"Residual distribution\", loc=\"left\", fontsize=12)\n", + "ax2.grid(axis=\"x\", visible=False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "within_2x = (points.residual.abs() <= np.log10(2)).mean() if is_log else None\n", + "if within_2x is not None:\n", + " print(f\"{within_2x:.0%} of museums are within 2× of their predicted visitors.\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-10", + "metadata": {}, + "source": [ + "## 5. Which museums beat (or miss) their city's size?\n", + "\n", + "`GET /residuals` ranks museums by actual ÷ predicted visitors. Above 1× (blue) the museum draws more\n", + "than its city's size alone would suggest; below 1× (orange) it draws fewer." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cell-11", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NameCityCountryPopulationVisitorsPredictedRatio
0LouvreParisFrance11060000.090000002710895.233.32
1Shenzhen MuseumShenzhenChina14678000.068050002811109.702.42
2National Museum of ChinaBeijingChina21893095.070317002959030.622.38
3British MuseumLondonUnited Kingdom11262000.064401202717195.792.37
4Natural History Museum, South KensingtonLondonUnited Kingdom11262000.063019722717195.792.32
5China Science and Technology MuseumBeijingChina21893095.064210002959030.622.17
6Nanjing MuseumNanjingChina9341685.056800002652816.452.14
7Metropolitan Museum of ArtNew York CityUnited States19268388.059840912910956.742.06
8Museum of ScienceBostonUnited States4453352.013240002412348.330.55
9Palacio de Cristal del RetiroMadridSpain6211000.013188232517507.580.52
10Smithsonian American Art Museum (with Renwick ...Washington, D.C.United States5230370.012734502462626.870.52
11Art Institute of ChicagoChicagoUnited States8609571.013242412625192.030.50
12Getty CenterLos AngelesUnited States11984083.013013322738940.930.48
13Centro Cultural Banco do BrasilSão PauloBrazil23086000.013642082979235.540.46
14Chinese Aviation MuseumBeijingChina21893095.012922782959030.620.44
15Moscow Kremlin MuseumMoscowRussia19100000.012401132907681.340.43
\n", + "
" + ], + "text/plain": [ + " Name City \\\n", + "0 Louvre Paris \n", + "1 Shenzhen Museum Shenzhen \n", + "2 National Museum of China Beijing \n", + "3 British Museum London \n", + "4 Natural History Museum, South Kensington London \n", + "5 China Science and Technology Museum Beijing \n", + "6 Nanjing Museum Nanjing \n", + "7 Metropolitan Museum of Art New York City \n", + "8 Museum of Science Boston \n", + "9 Palacio de Cristal del Retiro Madrid \n", + "10 Smithsonian American Art Museum (with Renwick ... Washington, D.C. \n", + "11 Art Institute of Chicago Chicago \n", + "12 Getty Center Los Angeles \n", + "13 Centro Cultural Banco do Brasil São Paulo \n", + "14 Chinese Aviation Museum Beijing \n", + "15 Moscow Kremlin Museum Moscow \n", + "\n", + " Country Population Visitors Predicted Ratio \n", + "0 France 11060000.0 9000000 2710895.23 3.32 \n", + "1 China 14678000.0 6805000 2811109.70 2.42 \n", + "2 China 21893095.0 7031700 2959030.62 2.38 \n", + "3 United Kingdom 11262000.0 6440120 2717195.79 2.37 \n", + "4 United Kingdom 11262000.0 6301972 2717195.79 2.32 \n", + "5 China 21893095.0 6421000 2959030.62 2.17 \n", + "6 China 9341685.0 5680000 2652816.45 2.14 \n", + "7 United States 19268388.0 5984091 2910956.74 2.06 \n", + "8 United States 4453352.0 1324000 2412348.33 0.55 \n", + "9 Spain 6211000.0 1318823 2517507.58 0.52 \n", + "10 United States 5230370.0 1273450 2462626.87 0.52 \n", + "11 United States 8609571.0 1324241 2625192.03 0.50 \n", + "12 United States 11984083.0 1301332 2738940.93 0.48 \n", + "13 Brazil 23086000.0 1364208 2979235.54 0.46 \n", + "14 China 21893095.0 1292278 2959030.62 0.44 \n", + "15 Russia 19100000.0 1240113 2907681.34 0.43 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "N = 8\n", + "over = pd.DataFrame(get(\"/residuals\", top=N, order=\"over\"))\n", + "under = pd.DataFrame(get(\"/residuals\", top=N, order=\"under\"))\n", + "res = (pd.concat([over, under.iloc[::-1]])\n", + " .drop_duplicates(\"Name\")\n", + " .sort_values(\"Ratio\"))\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 0.35 * len(res) + 1.2))\n", + "colors = [BLUE if r >= 1 else ORANGE for r in res.Ratio]\n", + "ax.barh(res.Name + \" (\" + res.City + \")\", np.log10(res.Ratio), color=colors, height=0.7)\n", + "ax.axvline(0, color=MUTED, lw=1)\n", + "ticks = np.array([0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20])\n", + "ticks = ticks[(np.log10(ticks) >= np.log10(res.Ratio).min() - 0.1) &\n", + " (np.log10(ticks) <= np.log10(res.Ratio).max() + 0.1)]\n", + "ax.set_xticks(np.log10(ticks), [f\"{t:g}×\" for t in ticks])\n", + "ax.set_xlabel(\"Actual ÷ predicted visitors (log scale)\")\n", + "ax.set_title(f\"Top {N} over- and under-performers\", loc=\"left\", fontsize=12)\n", + "ax.grid(axis=\"y\", visible=False)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "res[[\"Name\", \"City\", \"Country\", \"Population\", \"Visitors\", \"Predicted\", \"Ratio\"]] \\\n", + " .sort_values(\"Ratio\", ascending=False).round(2).reset_index(drop=True)" + ] + }, + { + "cell_type": "markdown", + "id": "cell-12", + "metadata": {}, + "source": [ + "## 6. Predict for new cities\n", + "\n", + "Edit `cities` and re-run. A single city uses `GET /predict?population=...`; a batch uses `POST /predict`.\n", + "The predictions are drawn on the fitted line from section 3." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cell-13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Montréal (single call): 2.14M visitors\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
PopulationPredicted visitors
Reykjavík140000.01547807.0
Lyon520000.01831517.0
Montréal1780000.02144653.0
Mexico City9200000.02647621.0
Tokyo14000000.02794109.0
\n", + "
" + ], + "text/plain": [ + " Population Predicted visitors\n", + "Reykjavík 140000.0 1547807.0\n", + "Lyon 520000.0 1831517.0\n", + "Montréal 1780000.0 2144653.0\n", + "Mexico City 9200000.0 2647621.0\n", + "Tokyo 14000000.0 2794109.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cities = {\"Reykjavík\": 140_000, \"Lyon\": 520_000, \"Montréal\": 1_780_000,\n", + " \"Mexico City\": 9_200_000, \"Tokyo\": 14_000_000}\n", + "\n", + "single = get(\"/predict\", population=cities[\"Montréal\"])\n", + "print(f\"Montréal (single call): {human(single['predicted_visitors'])} visitors\")\n", + "\n", + "pred = pd.DataFrame(post(\"/predict\", {\"populations\": list(cities.values())}), index=list(cities))\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 6))\n", + "ax.scatter(points.Population, points.Visitors, s=30, color=GRID, edgecolor=MUTED,\n", + " linewidth=0.5, label=\"Fitted museums\", zorder=2)\n", + "ax.plot(curve.population, curve.predicted_visitors, color=ORANGE, lw=2, label=\"Fit\", zorder=3)\n", + "ax.scatter(pred.population, pred.predicted_visitors, s=70, color=BLUE,\n", + " edgecolor=\"white\", linewidth=2, label=\"Predicted city\", zorder=4)\n", + "for city, r in pred.iterrows():\n", + " ax.annotate(f\"{city}: {human(r.predicted_visitors)}\", (r.population, r.predicted_visitors),\n", + " xytext=(8, -12), textcoords=\"offset points\", fontsize=9, color=INK)\n", + "if is_log:\n", + " ax.set_xscale(\"log\")\n", + " ax.set_yscale(\"log\")\n", + "human_axes(ax, is_log)\n", + "ax.set_xlabel(\"City population\")\n", + "ax.set_ylabel(\"Predicted annual visitors per museum\")\n", + "ax.set_title(\"Predicted visitors for new cities\", loc=\"left\", fontsize=12)\n", + "ax.legend(loc=\"upper left\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "pred.rename(columns={\"population\": \"Population\", \"predicted_visitors\": \"Predicted visitors\"}).round(0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/work/museum_regression.ipynb b/notebooks/work/museum_regression.ipynb deleted file mode 100644 index 90f077e..0000000 --- a/notebooks/work/museum_regression.ipynb +++ /dev/null @@ -1,313 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "0af7e8f5", - "metadata": {}, - "source": [ - "# Museum visitors vs. city population\n", - "\n", - "This notebook talks to the `museum_api` FastAPI server over HTTP: it starts the server (or uses one you already run), sends it the data, and plots the regression it returns.\n", - "\n", - "**Setup:** put `../../api/app/museum_api.py` next to this notebook, then `pip install scikit-learn pandas fastapi uvicorn requests matplotlib`." - ] - }, - { - "cell_type": "code", - "id": "4c50f329", - "metadata": { - "ExecuteTime": { - "end_time": "2026-10-07T21:11:58.303386100Z", - "start_time": "2026-10-07T21:11:57.570566Z" - } - }, - "source": [ - "import threading, time\n", - "import requests\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.ticker import FuncFormatter\n", - "\n", - "API = \"http://127.0.0.1:8000\" # change if your server runs elsewhere" - ], - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'matplotlib'", - "output_type": "error", - "traceback": [ - "\u001B[31m---------------------------------------------------------------------------\u001B[39m", - "\u001B[31mModuleNotFoundError\u001B[39m Traceback (most recent call last)", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[1]\u001B[39m\u001B[32m, line 5\u001B[39m\n\u001B[32m 1\u001B[39m \u001B[38;5;28;01mimport\u001B[39;00m threading, time\n\u001B[32m 2\u001B[39m \u001B[38;5;28;01mimport\u001B[39;00m requests\n\u001B[32m 3\u001B[39m \u001B[38;5;28;01mimport\u001B[39;00m numpy \u001B[38;5;28;01mas\u001B[39;00m np\n\u001B[32m 4\u001B[39m \u001B[38;5;28;01mimport\u001B[39;00m pandas \u001B[38;5;28;01mas\u001B[39;00m pd\n\u001B[32m----> \u001B[39m\u001B[32m5\u001B[39m \u001B[38;5;28;01mimport\u001B[39;00m matplotlib.pyplot \u001B[38;5;28;01mas\u001B[39;00m plt\n\u001B[32m 6\u001B[39m \u001B[38;5;28;01mfrom\u001B[39;00m matplotlib.ticker \u001B[38;5;28;01mimport\u001B[39;00m FuncFormatter\n\u001B[32m 7\u001B[39m \n\u001B[32m 8\u001B[39m API = \u001B[33m\"http://127.0.0.1:8000\"\u001B[39m \u001B[38;5;66;03m# change if your server runs elsewhere\u001B[39;00m\n", - "\u001B[31mModuleNotFoundError\u001B[39m: No module named 'matplotlib'" - ] - } - ], - "execution_count": 1 - }, - { - "cell_type": "markdown", - "id": "69524967", - "metadata": {}, - "source": [ - "## 1. Start the server\n", - "\n", - "If a server is already answering at `API` (e.g. you started it with `uvicorn museum_api:app` in a terminal), this cell just uses it. Otherwise it launches one in a background thread inside this kernel. Restart the kernel to stop it." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b9d41502", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'API' is not defined", - "output_type": "error", - "traceback": [ - "\u001B[31m---------------------------------------------------------------------------\u001B[39m", - "\u001B[31mNameError\u001B[39m Traceback (most recent call last)", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[2]\u001B[39m\u001B[32m, line 7\u001B[39m\n\u001B[32m 3\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m requests.get(f\"{API}/health\", timeout=\u001B[32m1\u001B[39m).ok\n\u001B[32m 4\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m requests.ConnectionError:\n\u001B[32m 5\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;01mFalse\u001B[39;00m\n\u001B[32m 6\u001B[39m \n\u001B[32m----> \u001B[39m\u001B[32m7\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28;01mnot\u001B[39;00m server_up():\n\u001B[32m 8\u001B[39m \u001B[38;5;28;01mimport\u001B[39;00m uvicorn\n\u001B[32m 9\u001B[39m \u001B[38;5;28;01mfrom\u001B[39;00m museum_api \u001B[38;5;28;01mimport\u001B[39;00m create_app\n\u001B[32m 10\u001B[39m server = uvicorn.Server(uvicorn.Config(create_app(), host=\u001B[33m\"127.0.0.1\"\u001B[39m, port=\u001B[32m8000\u001B[39m, log_level=\u001B[33m\"warning\"\u001B[39m))\n", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[2]\u001B[39m\u001B[32m, line 4\u001B[39m, in \u001B[36mserver_up\u001B[39m\u001B[34m()\u001B[39m\n\u001B[32m 1\u001B[39m \u001B[38;5;28;01mdef\u001B[39;00m server_up():\n\u001B[32m 2\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 3\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m requests.get(f\"{API}/health\", timeout=\u001B[32m1\u001B[39m).ok\n\u001B[32m----> \u001B[39m\u001B[32m4\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m requests.ConnectionError:\n\u001B[32m 5\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;01mFalse\u001B[39;00m\n", - "\u001B[31mNameError\u001B[39m: name 'API' is not defined" - ] - } - ], - "source": [ - "def server_up():\n", - " try:\n", - " return requests.get(f\"{API}/health\", timeout=1).ok\n", - " except requests.ConnectionError:\n", - " return False\n", - "\n", - "if not server_up():\n", - " import uvicorn\n", - " from api.app.museum_api import create_app\n", - " server = uvicorn.Server(uvicorn.Config(create_app(), host=\"127.0.0.1\", port=8000, log_level=\"warning\"))\n", - " threading.Thread(target=server.run, daemon=True).start()\n", - " for _ in range(50):\n", - " if server_up(): break\n", - " time.sleep(0.1)\n", - "\n", - "requests.get(f\"{API}/health\").json()" - ] - }, - { - "cell_type": "markdown", - "id": "742501f7", - "metadata": {}, - "source": [ - "## 2. Load your data\n", - "\n", - "Replace this with however you build your DataFrame. It needs the columns `Name, Visitors, City, Country, Population`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cb58b0f5", - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_csv(\"museums.csv\")\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "id": "362d6127", - "metadata": {}, - "source": [ - "## 3. Train the model through the API\n", - "\n", - "`scale=\"log\"` fits log(visitors) ~ log(population). Set `aggregate_by_city=True` to count each city once instead of once per museum." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ab229859", - "metadata": {}, - "outputs": [], - "source": [ - "def train(df, scale=\"log\", aggregate_by_city=False):\n", - " records = df[[\"Name\", \"Visitors\", \"City\", \"Country\", \"Population\"]].dropna().to_dict(\"records\")\n", - " r = requests.post(f\"{API}/train\", json={\"records\": records, \"scale\": scale,\n", - " \"aggregate_by_city\": aggregate_by_city})\n", - " r.raise_for_status()\n", - " return r.json()\n", - "\n", - "summary = train(df, scale=\"log\")\n", - "pd.Series(summary).to_frame(\"value\")" - ] - }, - { - "cell_type": "markdown", - "id": "f655bbcf", - "metadata": {}, - "source": [ - "## 4. Plot the regression" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1a23269f", - "metadata": {}, - "outputs": [], - "source": [ - "BLUE, ORANGE, INK, MUTED = \"#2a78d6\", \"#eb6834\", \"#0b0b0b\", \"#52514e\"\n", - "plt.rcParams.update({\"axes.spines.top\": False, \"axes.spines.right\": False,\n", - " \"axes.edgecolor\": MUTED, \"axes.labelcolor\": INK,\n", - " \"xtick.color\": MUTED, \"ytick.color\": MUTED,\n", - " \"axes.grid\": True, \"axes.axisbelow\": True, \"grid.color\": \"#e6e5e0\", \"grid.linewidth\": 0.8,\n", - " \"figure.dpi\": 110})\n", - "\n", - "def human(x, _=None):\n", - " for div, suf in ((1e9, \"B\"), (1e6, \"M\"), (1e3, \"K\")):\n", - " if abs(x) >= div: return f\"{x/div:g}{suf}\"\n", - " return f\"{x:g}\"\n", - "\n", - "points = pd.DataFrame(requests.get(f\"{API}/data\").json())\n", - "\n", - "# Fitted curve: ask the API to predict across the population range\n", - "grid = np.geomspace(points.Population.min(), points.Population.max(), 100)\n", - "curve = pd.DataFrame(requests.post(f\"{API}/predict\", json={\"populations\": grid.tolist()}).json())\n", - "\n", - "fig, ax = plt.subplots(figsize=(9, 6))\n", - "ax.scatter(points.Population, points.Visitors, s=40, color=BLUE, alpha=0.75,\n", - " edgecolor=\"white\", linewidth=1, label=\"Museums\", zorder=3)\n", - "ax.plot(curve.population, curve.predicted_visitors, color=ORANGE, lw=2,\n", - " label=f\"Fit: {summary['equation']}\", zorder=4)\n", - "\n", - "# Label the 5 biggest outliers (furthest from the line on the log scale)\n", - "points[\"logres\"] = np.log10(points.Visitors / points.Predicted)\n", - "for _, r in points.reindex(points.logres.abs().sort_values(ascending=False).index).head(5).iterrows():\n", - " ax.annotate(r.Name, (r.Population, r.Visitors), xytext=(6, 4),\n", - " textcoords=\"offset points\", fontsize=8, color=MUTED)\n", - "\n", - "if summary[\"scale\"] == \"log\":\n", - " ax.set_xscale(\"log\"); ax.set_yscale(\"log\")\n", - "ax.xaxis.set_major_formatter(FuncFormatter(human))\n", - "ax.yaxis.set_major_formatter(FuncFormatter(human))\n", - "ax.set_xlabel(\"City population\"); ax.set_ylabel(\"Annual visitors\")\n", - "cv = summary[\"cv_r2_5fold\"]\n", - "ax.set_title(f\"Visitors vs. city population R² = {summary['r2']:.2f}\"\n", - " + (f\" (cross-validated {cv:.2f})\" if cv is not None else \"\"),\n", - " loc=\"left\", fontsize=12, color=INK)\n", - "ax.legend(frameon=False, loc=\"upper left\")\n", - "plt.tight_layout(); plt.show()\n", - "\n", - "print(summary[\"interpretation\"])" - ] - }, - { - "cell_type": "markdown", - "id": "a4eafc4a", - "metadata": {}, - "source": [ - "## 5. Which museums beat (or miss) their city's size?\n", - "\n", - "Ratio = actual ÷ predicted visitors. Above 1× means the museum draws more than its city's size alone would suggest." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9a823747", - "metadata": {}, - "outputs": [], - "source": [ - "N = 8\n", - "over = pd.DataFrame(requests.get(f\"{API}/residuals\", params={\"top\": N, \"order\": \"over\"}).json())\n", - "under = pd.DataFrame(requests.get(f\"{API}/residuals\", params={\"top\": N, \"order\": \"under\"}).json())\n", - "res = pd.concat([over, under.iloc[::-1]]).drop_duplicates(\"Name\").iloc[::-1]\n", - "\n", - "fig, ax = plt.subplots(figsize=(9, 0.35 * len(res) + 1))\n", - "colors = [BLUE if r >= 1 else ORANGE for r in res.Ratio]\n", - "ax.barh(res.Name + \" (\" + res.City + \")\", np.log10(res.Ratio), color=colors, height=0.7)\n", - "ax.axvline(0, color=MUTED, lw=1)\n", - "ticks = np.array([0.1, 0.2, 0.5, 1, 2, 5, 10])\n", - "ticks = ticks[(np.log10(ticks) >= np.log10(res.Ratio).min() - 0.1) &\n", - " (np.log10(ticks) <= np.log10(res.Ratio).max() + 0.1)]\n", - "ax.set_xticks(np.log10(ticks), [f\"{t:g}×\" for t in ticks])\n", - "ax.set_xlabel(\"Actual ÷ predicted visitors (log scale)\")\n", - "ax.set_title(\"Over-performers (blue) and under-performers (orange)\", loc=\"left\", fontsize=12, color=INK)\n", - "ax.grid(axis=\"y\", visible=False)\n", - "plt.tight_layout(); plt.show()\n", - "\n", - "res[[\"Name\", \"City\", \"Country\", \"Population\", \"Visitors\", \"Predicted\", \"Ratio\"]].round(2)" - ] - }, - { - "cell_type": "markdown", - "id": "ce7a12d7", - "metadata": {}, - "source": [ - "## 6. Compare model variants\n", - "\n", - "Retrains the server with each setting and collects the fit statistics. The last setting tried stays loaded, so the final call re-trains the default." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9adca34e", - "metadata": {}, - "outputs": [], - "source": [ - "rows = []\n", - "for scale in (\"linear\", \"log\"):\n", - " for agg in (False, True):\n", - " s = train(df, scale=scale, aggregate_by_city=agg)\n", - " rows.append({k: s[k] for k in (\"scale\", \"aggregate_by_city\", \"n_samples\",\n", - " \"r2\", \"cv_r2_5fold\", \"pearson_r\", \"spearman_rho\")})\n", - "train(df, scale=\"log\") # restore the default model\n", - "pd.DataFrame(rows).round(3)" - ] - }, - { - "cell_type": "markdown", - "id": "1c0bcd2f", - "metadata": {}, - "source": [ - "## 7. Predict for any city" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6ff399ee", - "metadata": {}, - "outputs": [], - "source": [ - "cities = {\"Montréal\": 1_780_000, \"Lyon\": 520_000, \"Tokyo\": 14_000_000}\n", - "pred = requests.post(f\"{API}/predict\", json={\"populations\": list(cities.values())}).json()\n", - "pd.DataFrame(pred, index=cities.keys()).round(0)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}