{ "cells": [ { "cell_type": "markdown", "id": "3cb62171", "metadata": {}, "source": [ "# Disaster Lab — Python from the first line to a live alert\n", "\n", "Chiang Mai, September 2024. Rain fell in the hills for days. The Ping River climbed past the\n", "critical level at Nawarat Bridge, and on the night of 5 to 6 October it reached **5.30 metres**,\n", "the highest in fifty years. Six months later the ground shook from an earthquake 480 km away.\n", "\n", "This notebook teaches Python by building the program that joins such signals into one alert:\n", "rain, river, a forecast, a satellite picture, an archive of old disasters, and a seismometer.\n", "You start with one number and finish with an agent that reads **live data** from the internet.\n", "\n", "The same program runs as seven machines you can drive, with 中文, on the companion page:\n", "**https://krueng.ai/disaster_lab.html**. The eight `.py` files it shows are the steps of this\n", "notebook.\n", "\n", "**How to use this notebook.** Run each cell with `Shift+Enter`, in order. Read the words,\n", "run the code, look at the output. Then change a number and run it again. Nothing here can break\n", "your computer.\n", "\n", "**What you need.** Python 3.10 or newer, Jupyter (or Google Colab: *File → Upload notebook*),\n", "and three small files from the same folder as this notebook: `ping_sep_oct_2024.csv`,\n", "`archive.json` and `live_data.py`. The first cell fetches them if they are missing." ] }, { "cell_type": "code", "execution_count": 1, "id": "19ca6c7c", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.154975Z", "iopub.status.busy": "2026-10-01T07:03:24.154975Z", "iopub.status.idle": "2026-10-01T07:03:24.168201Z", "shell.execute_reply": "2026-10-01T07:03:24.168201Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "have ping_sep_oct_2024.csv\n", "have archive.json\n", "have live_data.py\n" ] } ], "source": [ "# Run me first. If the three data files are not next to this notebook, download them.\n", "import os\n", "import urllib.request\n", "\n", "SITE = \"https://krueng.ai/disaster_lab_assets/\"\n", "for name in [\"ping_sep_oct_2024.csv\", \"archive.json\", \"live_data.py\"]:\n", " if not os.path.exists(name):\n", " urllib.request.urlretrieve(SITE + name, name)\n", " print(\"downloaded\", name)\n", " else:\n", " print(\"have\", name)" ] }, { "cell_type": "markdown", "id": "f6c598cd", "metadata": {}, "source": [ "## 1 · Numbers, names and `print`\n", "\n", "A program works with **values** and gives them **names**. `rain_today = 88` makes a name\n", "that points at the number 88. `print(...)` shows a value. An **f-string**, `f\"...\"`, puts\n", "values inside text with `{}`. Comparing two values with `>=` gives `True` or `False`." ] }, { "cell_type": "code", "execution_count": 2, "id": "d0482593", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.168201Z", "iopub.status.busy": "2026-10-01T07:03:24.168201Z", "iopub.status.idle": "2026-10-01T07:03:24.175639Z", "shell.execute_reply": "2026-10-01T07:03:24.175639Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "88\n", "Rain today: 88 mm\n", "Rain today: 88 mm. Heavy? True\n" ] } ], "source": [ "rain_today = 88 # millimetres of rain in one day\n", "heavy = 50 # what we call heavy rain\n", "\n", "print(rain_today)\n", "print(\"Rain today:\", rain_today, \"mm\")\n", "print(f\"Rain today: {rain_today} mm. Heavy? {rain_today >= heavy}\")" ] }, { "cell_type": "markdown", "id": "0922e638", "metadata": {}, "source": [ "**Try it.** Change `rain_today` to 20 and run the cell again. Then make `heavy` 100." ] }, { "cell_type": "markdown", "id": "7363d78a", "metadata": {}, "source": [ "## 2 · Lists and loops — step 1 of the lab\n", "\n", "One number is one day. A **list** holds a whole week, in order, inside `[ ]`. You reach one\n", "value with its position, counting from **0**. A negative position counts from the end.\n", "`len()` tells you how many values there are." ] }, { "cell_type": "code", "execution_count": 3, "id": "0dba244c", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.178067Z", "iopub.status.busy": "2026-10-01T07:03:24.178067Z", "iopub.status.idle": "2026-10-01T07:03:24.182224Z", "shell.execute_reply": "2026-10-01T07:03:24.182224Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "88\n", "9\n", "7\n", "88 208\n" ] } ], "source": [ "RAIN = [4, 0, 12, 31, 88, 64, 9] # mm per day, Monday to Sunday\n", "\n", "print(RAIN[0]) # the first day\n", "print(RAIN[4]) # the fifth day\n", "print(RAIN[-1]) # the last day\n", "print(len(RAIN)) # how many days\n", "print(max(RAIN), sum(RAIN))" ] }, { "cell_type": "markdown", "id": "e4b72e59", "metadata": {}, "source": [ "A **`for` loop** repeats a block once for each value. `enumerate` gives you the position too.\n", "`if ... else` chooses between two blocks. Notice the four spaces: Python reads the **indentation**\n", "to know what is inside the loop and inside the `if`.\n", "\n", "This is `step1_rain.py` from the page, exactly." ] }, { "cell_type": "code", "execution_count": 4, "id": "de4e884e", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.182224Z", "iopub.status.busy": "2026-10-01T07:03:24.182224Z", "iopub.status.idle": "2026-10-01T07:03:24.190302Z", "shell.execute_reply": "2026-10-01T07:03:24.190302Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "day 1 - ok: 4 mm.\n", "day 2 - ok: 0 mm.\n", "day 3 - ok: 12 mm.\n", "day 4 - ok: 31 mm.\n", "day 5 - heavy rain: 88 mm. Watch the river.\n", "day 6 - heavy rain: 64 mm. Watch the river.\n", "day 7 - ok: 9 mm.\n" ] } ], "source": [ "HEAVY = 50 # 50 mm in one day is heavy rain\n", "\n", "for day, mm in enumerate(RAIN, start=1):\n", " if mm >= HEAVY:\n", " print(\"day\", day, \"- heavy rain:\", mm, \"mm. Watch the river.\")\n", " else:\n", " print(\"day\", day, \"- ok:\", mm, \"mm.\")" ] }, { "cell_type": "markdown", "id": "b40ce427", "metadata": {}, "source": [ "**Try it.** Set `HEAVY` to 30. How many days warn now? Then add a day to the list: `RAIN.append(120)`." ] }, { "cell_type": "markdown", "id": "247da07a", "metadata": {}, "source": [ "## 3 · Functions — step 2 of the lab\n", "\n", "A warning is yes or no. A **score** is better: a number from 0 (calm) to 1 (danger). To make\n", "scores we need a **function**: a named recipe that takes inputs and `return`s an answer.\n", "\n", "```python\n", "def name(inputs):\n", " \"\"\"What it does, in one line.\"\"\"\n", " ...\n", " return answer\n", "```\n", "\n", "`ramp(value, low, high)` is 0 below `low`, 1 above `high`, and a straight line between. Every\n", "signal in the lab becomes a score through it. The text in triple quotes is a **docstring**: a\n", "note to the reader, kept with the function." ] }, { "cell_type": "code", "execution_count": 5, "id": "418ea796", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.194285Z", "iopub.status.busy": "2026-10-01T07:03:24.192277Z", "iopub.status.idle": "2026-10-01T07:03:24.203581Z", "shell.execute_reply": "2026-10-01T07:03:24.202069Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0 mm -> rain score 0.00\n", " 20 mm -> rain score 0.00\n", " 50 mm -> rain score 0.50\n", " 80 mm -> rain score 1.00\n", " 120 mm -> rain score 1.00\n", " 2.40 m -> river score 0.00\n", " 3.00 m -> river score 0.00\n", " 3.35 m -> river score 0.50\n", " 3.70 m -> river score 1.00\n", " 5.30 m -> river score 1.00\n" ] } ], "source": [ "CRITICAL = 3.70 # at 3.70 m the Irrigation Office warns the city\n", "\n", "\n", "def ramp(value, low, high):\n", " \"\"\"0 below low, 1 above high, a straight line between them.\"\"\"\n", " if value <= low:\n", " return 0.0\n", " if value >= high:\n", " return 1.0\n", " return (value - low) / (high - low)\n", "\n", "\n", "def rain_score(mm):\n", " \"\"\"20 mm is nothing. 80 mm in one day is full danger.\"\"\"\n", " return ramp(mm, 20, 80)\n", "\n", "\n", "def river_score(metres):\n", " \"\"\"3.0 m is calm. At the critical level the score is 1.\"\"\"\n", " return ramp(metres, 3.0, CRITICAL)\n", "\n", "\n", "for mm in [0, 20, 50, 80, 120]:\n", " print(f\"{mm:4} mm -> rain score {rain_score(mm):.2f}\")\n", "for metres in [2.4, 3.0, 3.35, 3.70, 5.30]:\n", " print(f\"{metres:5.2f} m -> river score {river_score(metres):.2f}\")" ] }, { "cell_type": "markdown", "id": "809871b6", "metadata": {}, "source": [ "**The shape of a file.** In a notebook you run cells one by one. A `.py` file runs from the top,\n", "so the page's files give it a shape: the top only *defines* things, and `main()` *does* things.\n", "The last two lines run `main()` only when you run the file itself, not when another file\n", "imports it. You will see this shape in every file on the page." ] }, { "cell_type": "code", "execution_count": 6, "id": "1c570208", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.205589Z", "iopub.status.busy": "2026-10-01T07:03:24.205589Z", "iopub.status.idle": "2026-10-01T07:03:24.211137Z", "shell.execute_reply": "2026-10-01T07:03:24.211137Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "day 1: rain 0.00 river 0.00\n", "day 2: rain 0.00 river 0.00\n", "day 3: rain 0.00 river 0.00\n", "day 4: rain 0.18 river 0.00\n", "day 5: rain 1.00 river 0.86\n", "day 6: rain 0.73 river 1.00\n", "day 7: rain 0.00 river 1.00\n" ] } ], "source": [ "def main():\n", " \"\"\"Everything the program does, in one place.\"\"\"\n", " rain = [4, 0, 12, 31, 88, 64, 9]\n", " river = [2.4, 2.4, 2.5, 2.9, 3.6, 4.1, 3.9]\n", " for day in range(len(rain)):\n", " print(f\"day {day + 1}: rain {rain_score(rain[day]):.2f} \"\n", " f\"river {river_score(river[day]):.2f}\")\n", "\n", "\n", "if __name__ == \"__main__\":\n", " main()" ] }, { "cell_type": "markdown", "id": "1b8dbd37", "metadata": {}, "source": [ "## 4 · Reading data from a file\n", "\n", "Real data lives in files. `ping_sep_oct_2024.csv` is a text table, one line per day, with the\n", "columns in the first line. Python's `csv` module reads it; `DictReader` gives each row as a\n", "**dictionary**, so `row[\"river_m\"]` is that day's river level — as text. `float()` and `int()`\n", "turn text into numbers.\n", "\n", "`with open(...) as f:` opens the file and closes it again when the block ends, even if\n", "something goes wrong inside." ] }, { "cell_type": "code", "execution_count": 7, "id": "0af390ec", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.214227Z", "iopub.status.busy": "2026-10-01T07:03:24.214227Z", "iopub.status.idle": "2026-10-01T07:03:24.221606Z", "shell.execute_reply": "2026-10-01T07:03:24.221606Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "30 days, from 2024-09-10 to 2024-10-09\n", "highest river: 5.3 m on 2024-10-06 - * reported, the record\n", "most rain: 120 mm on 2024-10-04\n" ] } ], "source": [ "import csv\n", "\n", "DATE, RAIN, RAIN_ERA5, RIVER, GLOFAS, NOTE = [], [], [], [], [], []\n", "with open(\"ping_sep_oct_2024.csv\", encoding=\"utf-8\") as f:\n", " for row in csv.DictReader(f):\n", " DATE.append(row[\"date\"])\n", " RAIN.append(int(row[\"rain_mm\"]))\n", " RAIN_ERA5.append(float(row[\"rain_era5_mm\"]))\n", " RIVER.append(float(row[\"river_m\"]))\n", " GLOFAS.append(float(row[\"glofas_m3s\"]))\n", " NOTE.append(row[\"note\"])\n", "\n", "print(len(DATE), \"days, from\", DATE[0], \"to\", DATE[-1])\n", "highest = RIVER.index(max(RIVER))\n", "print(\"highest river:\", RIVER[highest], \"m on\", DATE[highest], \"-\", NOTE[highest])\n", "print(\"most rain:\", max(RAIN), \"mm on\", DATE[RAIN.index(max(RAIN))])" ] }, { "cell_type": "markdown", "id": "56a00ebc", "metadata": {}, "source": [ "**Two rain columns.** `rain_mm` is the teaching series the page uses. `rain_era5_mm` is real:\n", "daily rain for Chiang Mai from the ERA5 reanalysis, a weather model that is fed with real\n", "observations, fetched from the Open-Meteo archive. The river levels marked `*` were reported in\n", "the news; the other days are filled in to join them. `glofas_m3s` is a river *model* for a cell\n", "on the Ping. Always know which column is measured and which is made." ] }, { "cell_type": "code", "execution_count": 8, "id": "b8b01a61", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.223628Z", "iopub.status.busy": "2026-10-01T07:03:24.223628Z", "iopub.status.idle": "2026-10-01T07:03:24.228753Z", "shell.execute_reply": "2026-10-01T07:03:24.228753Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "date teaching ERA5 river note\n", "2024-09-22 36 mm 20.6 2.80 filled in\n", "2024-09-23 64 mm 61.6 3.05 filled in\n", "2024-09-24 98 mm 57.9 3.34 * reported, 10:00\n", "2024-09-25 40 mm 38.8 4.32 * the Irrigation Office's forecast peak\n", "2024-09-26 12 mm 15.1 4.93 * reported, over the banks\n", "2024-09-27 5 mm 4.2 4.40 filled in\n" ] } ], "source": [ "print(\"date teaching ERA5 river note\")\n", "for i in range(12, 18):\n", " print(f\"{DATE[i]} {RAIN[i]:4} mm {RAIN_ERA5[i]:5.1f} {RIVER[i]:5.2f} {NOTE[i]}\")" ] }, { "cell_type": "markdown", "id": "a16bb7ba", "metadata": {}, "source": [ "A picture says it faster. `matplotlib` draws charts. If it is not installed, run\n", "`pip install matplotlib` in a terminal, or skip this cell." ] }, { "cell_type": "code", "execution_count": 9, "id": "80c6bc16", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:24.228753Z", "iopub.status.busy": "2026-10-01T07:03:24.228753Z", "iopub.status.idle": "2026-10-01T07:03:25.127805Z", "shell.execute_reply": "2026-10-01T07:03:25.127805Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "fig, ax_rain = plt.subplots(figsize=(10, 4))\n", "ax_rain.bar(DATE, RAIN_ERA5, color=\"#57a8ff\", label=\"rain, ERA5 (mm)\")\n", "ax_rain.set_ylabel(\"rain, mm\")\n", "ax_river = ax_rain.twinx()\n", "ax_river.plot(DATE, RIVER, color=\"#1fb894\", linewidth=2.5, label=\"river at P.1 (m)\")\n", "ax_river.axhline(3.70, color=\"#ff5d6c\", linestyle=\"--\", label=\"3.70 m critical\")\n", "ax_river.set_ylabel(\"river, m\")\n", "ax_rain.set_xticks(DATE[::7])\n", "fig.legend(loc=\"upper left\")\n", "plt.title(\"Chiang Mai, 10 September to 9 October 2024\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "1165f544", "metadata": {}, "source": [ "## 5 · Slices and the forecast — step 3 of the lab\n", "\n", "The river does not jump; it climbs. Yesterday is `levels[day - 1]`. A **slice**\n", "`RIVER[13:17]` gives positions 13, 14, 15 and 16 — the end is not included.\n", "\n", "The forecast takes today's climb and adds it again. That is the whole forecast." ] }, { "cell_type": "code", "execution_count": 10, "id": "7c072237", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.131720Z", "iopub.status.busy": "2026-10-01T07:03:25.131720Z", "iopub.status.idle": "2026-10-01T07:03:25.138530Z", "shell.execute_reply": "2026-10-01T07:03:25.138530Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[3.05, 3.34, 4.32, 4.93]\n", "worst day: 2024-09-26 forecast 5.54 m, really 4.40 m\n" ] } ], "source": [ "print(RIVER[13:17]) # 23 to 26 September\n", "\n", "\n", "def forecast(levels, day):\n", " \"\"\"Tomorrow's level, if the river climbs the same as it did today.\"\"\"\n", " if day == 0:\n", " return levels[0]\n", " climb = levels[day] - levels[day - 1]\n", " return levels[day] + climb\n", "\n", "\n", "def forecast_score(metres):\n", " \"\"\"Water enters the first streets at 3.9 m, so 3.9 m is full danger.\"\"\"\n", " return ramp(metres, 3.3, 3.9)\n", "\n", "\n", "errors = []\n", "for day in range(1, len(RIVER) - 1):\n", " guess = forecast(RIVER, day)\n", " real = RIVER[day + 1]\n", " errors.append((abs(guess - real), day, guess, real))\n", "\n", "worst = max(errors)\n", "print(f\"worst day: {DATE[worst[1]]} forecast {worst[2]:.2f} m, really {worst[3]:.2f} m\")" ] }, { "cell_type": "markdown", "id": "a2c7f792", "metadata": {}, "source": [ "`errors` is a list of **tuples** (groups of values). `max()` compares the first value of each\n", "tuple, so it finds the biggest error. **Try it.** Print the three worst days with `sorted(errors)[-3:]`." ] }, { "cell_type": "markdown", "id": "c702be29", "metadata": {}, "source": [ "## 6 · Imports and `math` — step 4, the earthquake\n", "\n", "Python comes with toolboxes called **modules**. `import math` opens one. `math.log10(x)` is\n", "how distance fades: ten times further is one step less, a hundred times further is two steps less.\n", "\n", "An earthquake cannot be forecast, only measured. A seismometer hears the fast P wave first and\n", "the slower S wave later; the gap gives the distance. Magnitude and distance give a rough shaking.\n", "The intensity rule below is a classroom rule, fitted to the 2025 quake; real agencies use better ones." ] }, { "cell_type": "code", "execution_count": 11, "id": "7820587f", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.138530Z", "iopub.status.busy": "2026-10-01T07:03:25.138530Z", "iopub.status.idle": "2026-10-01T07:03:25.147459Z", "shell.execute_reply": "2026-10-01T07:03:25.147459Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "P to S gap of 64 s -> about 480.0 km away\n" ] } ], "source": [ "import math\n", "\n", "P_SPEED = 5.0 # km per second, a P wave in granite\n", "S_SPEED = 3.0 # km per second, about 60 percent of the P wave\n", "KM_PER_GAP_SECOND = 7.5 # from the two speeds: 5 x 3 / (5 - 3)\n", "\n", "\n", "def distance_from_gap(gap_seconds):\n", " \"\"\"Seconds between the P wave and the S wave, times 7.5, is the distance.\"\"\"\n", " return gap_seconds * KM_PER_GAP_SECOND\n", "\n", "\n", "def warning_seconds(km):\n", " \"\"\"The P wave arrives first. The time before the S wave is the warning time.\"\"\"\n", " return km / S_SPEED - km / P_SPEED\n", "\n", "\n", "def intensity(magnitude, km):\n", " \"\"\"How strong the shaking feels, from 1 to 12. A simple classroom rule.\"\"\"\n", " value = 1.5 * magnitude - 3 * math.log10(max(km, 1)) + 1.5\n", " return max(1.0, min(12.0, value))\n", "\n", "\n", "def shake_score(magnitude, km):\n", " return ramp(intensity(magnitude, km), 3, 8)\n", "\n", "\n", "print(\"P to S gap of 64 s -> about\", distance_from_gap(64), \"km away\")" ] }, { "cell_type": "markdown", "id": "f62a7875", "metadata": {}, "source": [ "Where did \"480 km\" come from? From the map. Two points on the Earth are a distance apart that\n", "you can compute from their latitude and longitude with the **haversine** formula. `math.radians`\n", "turns degrees into the angle unit the formula wants. This function will matter again in the\n", "live-data section: it tells us how far away today's earthquakes are." ] }, { "cell_type": "code", "execution_count": 12, "id": "8947e6f4", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.147459Z", "iopub.status.busy": "2026-10-01T07:03:25.147459Z", "iopub.status.idle": "2026-10-01T07:03:25.158414Z", "shell.execute_reply": "2026-10-01T07:03:25.158414Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mandalay 15 km shaking 9.5 warning 2.0 s score 1.00\n", "Chiang Mai 478 km shaking 5.0 warning 63.8 s score 0.40\n", "Bangkok 1039 km shaking 4.0 warning 138.5 s score 0.20\n" ] } ], "source": [ "def distance_km(lat1, lon1, lat2, lon2):\n", " \"\"\"Distance between two places on the Earth, in km (the haversine formula).\"\"\"\n", " radius = 6371.0\n", " d_lat = math.radians(lat2 - lat1)\n", " d_lon = math.radians(lon2 - lon1)\n", " a = (math.sin(d_lat / 2) ** 2\n", " + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2))\n", " * math.sin(d_lon / 2) ** 2)\n", " return 2 * radius * math.atan2(math.sqrt(a), math.sqrt(1 - a))\n", "\n", "\n", "CHIANG_MAI = (18.79, 98.98)\n", "EPICENTRE_2025 = (22.011, 95.936) # USGS, 28 March 2025, M7.7, 10 km deep\n", "\n", "for city, (lat, lon) in [(\"Mandalay\", (21.98, 96.08)), (\"Chiang Mai\", CHIANG_MAI),\n", " (\"Bangkok\", (13.75, 100.52))]:\n", " km = distance_km(*EPICENTRE_2025, lat, lon)\n", " print(f\"{city:11} {km:5.0f} km shaking {intensity(7.7, km):4.1f} \"\n", " f\"warning {warning_seconds(km):5.1f} s score {shake_score(7.7, km):.2f}\")" ] }, { "cell_type": "markdown", "id": "2223eb07", "metadata": {}, "source": [ "## 7 · Nested lists — step 5, the satellite\n", "\n", "A picture is a grid: a list of rows, and each row a list of numbers. `BEFORE[1][2]` is row 1,\n", "column 2. `zip(a, b)` walks two lists side by side. The machine subtracts the two pictures cell\n", "by cell and counts the cells that changed a lot." ] }, { "cell_type": "code", "execution_count": 13, "id": "626f0f2f", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.162515Z", "iopub.status.busy": "2026-10-01T07:03:25.160967Z", "iopub.status.idle": "2026-10-01T07:03:25.170502Z", "shell.execute_reply": "2026-10-01T07:03:25.170502Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2 -> 1\n", "changed: 36% satellite score 1.00\n", ". . . . . .\n", ". # . # . .\n", ". # . # # .\n", "# # . # # .\n", ". # . # # .\n", ". . . # . .\n" ] } ], "source": [ "# Two tiny radar pictures, 6 by 6 cells. 9 is bright (dry land), 0 is dark (water).\n", "BEFORE = [\n", " [7, 8, 7, 6, 8, 7],\n", " [8, 7, 2, 6, 7, 8], # the river is the dark 2 in the middle\n", " [7, 6, 2, 7, 8, 7],\n", " [8, 7, 2, 6, 7, 6],\n", " [7, 8, 3, 7, 8, 7],\n", " [8, 7, 2, 7, 7, 8],\n", "]\n", "AFTER = [\n", " [7, 8, 7, 6, 8, 7],\n", " [8, 2, 1, 2, 7, 8], # the dark water is wider now\n", " [7, 1, 1, 2, 2, 7],\n", " [2, 1, 1, 2, 1, 6],\n", " [7, 2, 1, 1, 2, 7],\n", " [8, 7, 2, 2, 7, 8],\n", "]\n", "BIG_CHANGE = 4 # a cell that changed by 4 or more is a real change, not noise\n", "\n", "\n", "def changed_fraction(before, after):\n", " \"\"\"What part of the picture changed? 0.0 is nothing, 1.0 is everything.\"\"\"\n", " changed = 0\n", " total = 0\n", " for row_before, row_after in zip(before, after):\n", " for old, new in zip(row_before, row_after):\n", " total += 1\n", " if abs(new - old) >= BIG_CHANGE:\n", " changed += 1\n", " return changed / total\n", "\n", "\n", "def satellite_score(fraction):\n", " \"\"\"5 percent changed is noise. 30 percent changed is a flood.\"\"\"\n", " return ramp(fraction, 0.05, 0.30)\n", "\n", "\n", "print(BEFORE[1][2], \"->\", AFTER[1][2])\n", "fraction = changed_fraction(BEFORE, AFTER)\n", "print(f\"changed: {fraction:.0%} satellite score {satellite_score(fraction):.2f}\")\n", "for row_before, row_after in zip(BEFORE, AFTER):\n", " marks = [\"#\" if abs(new - old) >= BIG_CHANGE else \".\" for old, new in zip(row_before, row_after)]\n", " print(\" \".join(marks))" ] }, { "cell_type": "markdown", "id": "9949940f", "metadata": {}, "source": [ "The last loop uses a **list comprehension**: `[x for item in things]` builds a list in one line.\n", "**Try it.** Set `BIG_CHANGE` to 1, then to 8, and watch the map." ] }, { "cell_type": "markdown", "id": "a5eec586", "metadata": {}, "source": [ "## 8 · Strings, sets and dictionaries — step 6, the archive\n", "\n", "`archive.json` holds nine real events. `json.load` turns the file into a list of\n", "**dictionaries**: `record[\"year\"]`, `record[\"text\"]`.\n", "\n", "Text is a **string**. `.lower()` makes it small letters, `.split()` cuts it into words.\n", "A **set** `{...}` keeps each word once, and `a & b` gives the words two sets share.\n", "`sorted(..., key=...)` sorts by a value you choose; `lambda` is a tiny function written in place." ] }, { "cell_type": "code", "execution_count": 14, "id": "f49eb0d8", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.170502Z", "iopub.status.busy": "2026-10-01T07:03:25.170502Z", "iopub.status.idle": "2026-10-01T07:03:25.182930Z", "shell.execute_reply": "2026-10-01T07:03:25.182930Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9 records. The first:\n", "2004 tsunami - Khao Lak and Phuket\n", "query words: ['days', 'heavy', 'markets', 'near', 'rain', 'rising', 'river']\n", " 5 shared 2024 flood Chiang Mai ['days', 'heavy', 'markets', 'rain', 'river']\n", " 2 shared 2011 flood Central Thailand ['heavy', 'rain']\n", " 1 shared 2005 flood Chiang Mai ['river']\n" ] } ], "source": [ "import json\n", "\n", "with open(\"archive.json\", encoding=\"utf-8\") as f:\n", " ARCHIVE = json.load(f)\n", "\n", "print(len(ARCHIVE), \"records. The first:\")\n", "print(ARCHIVE[0][\"year\"], ARCHIVE[0][\"kind\"], \"-\", ARCHIVE[0][\"place\"])\n", "\n", "# Words that every text shares. They say nothing, so the search ignores them.\n", "STOP_WORDS = {\"the\", \"and\", \"for\", \"with\", \"from\"}\n", "\n", "\n", "def words(text):\n", " \"\"\"The words in a text: lower case, three letters or more, and not a stop word.\"\"\"\n", " cleaned = \"\".join(letter.lower() if letter.isalnum() else \" \" for letter in text)\n", " kept = (word for word in cleaned.split() if len(word) >= 3)\n", " return {word for word in kept if word not in STOP_WORDS}\n", "\n", "\n", "def search(query, archive):\n", " \"\"\"Every record with the count of words it shares with the query, best first.\"\"\"\n", " query_words = words(query)\n", " matches = []\n", " for record in archive:\n", " record_text = record[\"text\"] + \" \" + record[\"place\"] + \" \" + record[\"kind\"]\n", " shared = query_words & words(record_text)\n", " matches.append((len(shared), record, sorted(shared)))\n", " matches.sort(key=lambda match: match[0], reverse=True)\n", " return matches\n", "\n", "\n", "def archive_score(shared_words):\n", " \"\"\"One shared word is chance. Four shared words is a real match.\"\"\"\n", " return ramp(shared_words, 1, 4)\n", "\n", "\n", "query = \"heavy rain for days, the river is rising, markets near the river\"\n", "print(\"query words:\", sorted(words(query)))\n", "for count, record, shared in search(query, ARCHIVE)[:3]:\n", " print(f\" {count} shared {record['year']} {record['kind']:10} {record['place']:22} {shared}\")" ] }, { "cell_type": "markdown", "id": "1cf176b3", "metadata": {}, "source": [ "**Try it.** Search for `\"the ground shook in Chiang Mai\"`. Then add a tenth record to `ARCHIVE`\n", "— a dictionary with `year`, `kind`, `place` and `text` — and search for it." ] }, { "cell_type": "markdown", "id": "36424fab", "metadata": {}, "source": [ "## 9 · Classes — step 7, one class for every signal\n", "\n", "Five scorers, one shape. A **class** is a value that carries its own functions, called\n", "**methods**. `__init__` runs when you build one: `Signal(\"rain\", 98)`. Inside the class,\n", "`self` means *this one*.\n", "\n", "The kind is handed in, and the class reads it: `SCORERS[self.kind]` picks the right scorer\n", "from a dictionary. Yes — **functions are values too**, and a dictionary can hold them.\n", "One class, not five.\n", "\n", "The coordinator does not add the scores. It multiplies the **odds**. A score of 1 multiplies\n", "by ten, a score of 0 divides by ten, and 0.5 changes nothing — so a missing signal is 0.5." ] }, { "cell_type": "code", "execution_count": 15, "id": "9ba4b888", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.182930Z", "iopub.status.busy": "2026-10-01T07:03:25.182930Z", "iopub.status.idle": "2026-10-01T07:03:25.196041Z", "shell.execute_reply": "2026-10-01T07:03:25.194935Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rain value 98 score 1.00 odds x10.00\n", "river value 3.34 score 0.49 odds x0.94\n", "forecast value 3.63 score 0.55 odds x1.26\n", "satellite value None score 0.50 odds x1.00\n", "archive value 2 score 0.33 odds x0.46\n", "chance of a flood tomorrow: 38% -> YELLOW - watch closely\n" ] } ], "source": [ "PRIOR = 0.10 # our starting guess for a flood tomorrow, before we look at any signal\n", "\n", "SCORERS = {\"rain\": rain_score, \"river\": river_score, \"forecast\": forecast_score,\n", " \"satellite\": satellite_score, \"archive\": archive_score}\n", "\n", "\n", "class Signal:\n", " \"\"\"One signal. The kind says how its value becomes a score.\"\"\"\n", "\n", " def __init__(self, kind, value):\n", " self.kind = kind\n", " self.value = value\n", "\n", " def score(self):\n", " \"\"\"0 is calm, 1 is danger. A missing value is 0.5: it says nothing.\"\"\"\n", " if self.value is None:\n", " return 0.5\n", " return SCORERS[self.kind](self.value)\n", "\n", " def weight(self):\n", " \"\"\"How much this signal multiplies the odds. Score 0.5 gives x1: no change.\"\"\"\n", " return 10 ** (2 * self.score() - 1)\n", "\n", "\n", "def fuse(signals, prior):\n", " \"\"\"Start with the prior. Multiply the odds by every signal. Give back a chance.\"\"\"\n", " odds = prior / (1 - prior)\n", " for signal in signals:\n", " odds = odds * signal.weight()\n", " return odds / (1 + odds)\n", "\n", "\n", "def decide(chance, threshold):\n", " if chance >= threshold:\n", " return \"RED - warn people now\"\n", " if chance >= threshold / 2:\n", " return \"YELLOW - watch closely\"\n", " return \"GREEN - calm\"\n", "\n", "\n", "# The morning of 24 September 2024 in Chiang Mai. No satellite picture yet.\n", "signals = [Signal(\"rain\", 98), Signal(\"river\", 3.34), Signal(\"forecast\", 3.63),\n", " Signal(\"satellite\", None), Signal(\"archive\", 2)]\n", "for signal in signals:\n", " print(f\"{signal.kind:10} value {str(signal.value):>5} \"\n", " f\"score {signal.score():.2f} odds x{signal.weight():.2f}\")\n", "chance = fuse(signals, PRIOR)\n", "print(f\"chance of a flood tomorrow: {chance:.0%} -> {decide(chance, 0.5)}\")" ] }, { "cell_type": "markdown", "id": "32bee969", "metadata": {}, "source": [ "**Try it.** Give every signal the value `None`: each scores 0.5, and the chance stays at the prior, 10%.\n", "Then give only the rain 98: the chance jumps to 53%, just over the line, so one strong signal can turn\n", "it red alone. Now add `Signal(\"river\", 2.4)`, a calm river, and the chance falls back to 10%." ] }, { "cell_type": "markdown", "id": "afd18314", "metadata": {}, "source": [ "## 10 · The whole agent, tested — step 8\n", "\n", "Now the test. `evaluate()` replays the thirty days. Each day the agent reads rain, river and\n", "forecast, decides for tomorrow, and then we look at tomorrow. Water in the first streets\n", "(3.90 m) is a flood. Four counts come out: hits, false alarms, misses and quiet days." ] }, { "cell_type": "code", "execution_count": 16, "id": "e77d632a", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.198176Z", "iopub.status.busy": "2026-10-01T07:03:25.198176Z", "iopub.status.idle": "2026-10-01T07:03:25.206125Z", "shell.execute_reply": "2026-10-01T07:03:25.206125Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "threshold hits false alarms misses quiet\n", " 0.3 8 1 0 19\n", " 0.5 7 1 1 19\n", " 0.7 4 0 4 20\n", " 0.9 1 0 7 20\n" ] } ], "source": [ "FLOOD_LEVEL = 3.90 # water enters the first streets at +3.90 m\n", "\n", "\n", "def evaluate(threshold):\n", " \"\"\"Replay the thirty days. Each day, decide for tomorrow. Then look at tomorrow.\"\"\"\n", " hits = false_alarms = misses = quiet = 0\n", " for day in range(1, len(RIVER) - 1):\n", " signals = [Signal(\"rain\", RAIN[day]), Signal(\"river\", RIVER[day]),\n", " Signal(\"forecast\", forecast(RIVER, day))]\n", " alert = fuse(signals, PRIOR) >= threshold\n", " flood = RIVER[day + 1] >= FLOOD_LEVEL\n", " if alert and flood:\n", " hits += 1\n", " elif alert:\n", " false_alarms += 1\n", " elif flood:\n", " misses += 1\n", " else:\n", " quiet += 1\n", " return hits, false_alarms, misses, quiet\n", "\n", "\n", "print(\"threshold hits false alarms misses quiet\")\n", "for threshold in [0.3, 0.5, 0.7, 0.9]:\n", " hits, false_alarms, misses, quiet = evaluate(threshold)\n", " print(f\" {threshold:.1f} {hits:5} {false_alarms:12} {misses:6} {quiet:5}\")" ] }, { "cell_type": "markdown", "id": "1856d6c9", "metadata": {}, "source": [ "Read the table. A low line misses nothing and cries wolf. A high line never cries wolf and\n", "misses floods. No line gives zero of both. The threshold is not a maths choice; it is a choice\n", "about people. Here is the chance for every day, with the floods shaded." ] }, { "cell_type": "code", "execution_count": 17, "id": "12cbcd94", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.206125Z", "iopub.status.busy": "2026-10-01T07:03:25.206125Z", "iopub.status.idle": "2026-10-01T07:03:25.378999Z", "shell.execute_reply": "2026-10-01T07:03:25.377952Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "chances = [fuse([Signal(\"rain\", RAIN[d]), Signal(\"river\", RIVER[d]),\n", " Signal(\"forecast\", forecast(RIVER, d))], PRIOR) for d in range(len(RIVER))]\n", "\n", "fig, ax = plt.subplots(figsize=(10, 3.5))\n", "ax.plot(DATE, chances, color=\"#ffc247\", linewidth=2.5, label=\"chance of a flood tomorrow\")\n", "ax.axhline(0.5, color=\"#ff5d6c\", linestyle=\"--\", label=\"threshold 0.5\")\n", "for d in range(len(RIVER) - 1):\n", " if RIVER[d + 1] >= FLOOD_LEVEL:\n", " ax.axvspan(d - 0.5, d + 0.5, color=\"#57a8ff\", alpha=0.25)\n", "ax.set_xticks(DATE[::7])\n", "ax.set_ylim(0, 1)\n", "ax.legend(loc=\"upper left\")\n", "plt.title(\"blue: the next day was a flood\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "950ea5c3", "metadata": {}, "source": [ "## 11 · Live data\n", "\n", "Everything so far used one month in 2024. Now the same agent reads **today**. The file\n", "`live_data.py` beside this notebook asks four free websites, none of which needs an API key:\n", "\n", "| function | source | what it gives | measured or model? |\n", "|---|---|---|---|\n", "| `rain_days()` | Open-Meteo weather | daily rain, the past 7 days and the next 7 | past days: a model fed with observations; future: a forecast |\n", "| `river_days()` | Open-Meteo flood API | river flow in m³/s, the past 30 days and the next 7 | a model (GloFAS), not the P.1 gauge: the shape is right, the scale is not |\n", "| `quakes()` | USGS | earthquakes in the last hours, anywhere | measured |\n", "| `events()` | NASA EONET | floods, storms and quakes reported in the last days | reported |\n", "\n", "`import live_data` loads that file as a module, like `math`. The `try ... except` around each\n", "call means a missing internet connection prints a message instead of stopping the notebook.\n", "There is no public API for the real P.1 gauge; its readings are on thaiwater.net." ] }, { "cell_type": "code", "execution_count": 18, "id": "400ac49b", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:25.378999Z", "iopub.status.busy": "2026-10-01T07:03:25.378999Z", "iopub.status.idle": "2026-10-01T07:03:26.554281Z", "shell.execute_reply": "2026-10-01T07:03:26.554281Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "today is 2026-10-01\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2026-09-24 0.4 mm past rain score 0.00\n", "2026-09-25 2.2 mm past rain score 0.00\n", "2026-09-26 3.5 mm past rain score 0.00\n", "2026-09-27 2.9 mm past rain score 0.00\n", "2026-09-28 24.0 mm past rain score 0.07\n", "2026-09-29 51.5 mm past rain score 0.53\n", "2026-09-30 3.3 mm past rain score 0.00\n", "2026-10-01 0.0 mm past rain score 0.00\n", "2026-10-02 1.7 mm forecast rain score 0.00\n", "2026-10-03 4.1 mm forecast rain score 0.00\n", "2026-10-04 9.5 mm forecast rain score 0.00\n", "2026-10-05 7.8 mm forecast rain score 0.00\n", "2026-10-06 20.0 mm forecast rain score 0.00\n", "2026-10-07 5.4 mm forecast rain score 0.00\n" ] } ], "source": [ "import datetime\n", "import live_data\n", "\n", "today = datetime.date.today().isoformat()\n", "print(\"today is\", today)\n", "\n", "try:\n", " rain_live = live_data.rain_days(live_data.CHIANG_MAI, past=7, future=7)\n", " for day, mm in rain_live:\n", " label = \"forecast\" if day > today else \"past\"\n", " print(f\"{day} {mm:5.1f} mm {label} rain score {rain_score(mm):.2f}\")\n", "except Exception as problem:\n", " rain_live = []\n", " print(\"no live rain data:\", problem)" ] }, { "cell_type": "markdown", "id": "40734a9d", "metadata": {}, "source": [ "The GloFAS river is a model, so its numbers are not the gauge's metres. We cannot use the\n", "3.70 m critical level. Instead we ask: **how unusual is today's flow for this river?** Divide\n", "today by the past month's typical (median) flow. Twice the usual flow is worrying; three times is danger." ] }, { "cell_type": "code", "execution_count": 19, "id": "251cf914", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:26.554281Z", "iopub.status.busy": "2026-10-01T07:03:26.554281Z", "iopub.status.idle": "2026-10-01T07:03:27.550086Z", "shell.execute_reply": "2026-10-01T07:03:27.550086Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "usual flow this month 54 m3/s, on 2026-10-01 47 m3/s = 0.87 times usual -> river score 0.00\n" ] } ], "source": [ "import statistics\n", "\n", "try:\n", " river_live = live_data.river_days(live_data.PING_GLOFAS, past=30, future=7)\n", " past_flows = [flow for day, flow in river_live if day <= today and flow is not None]\n", " usual = statistics.median(past_flows)\n", " latest_day, latest_flow = [(day, flow) for day, flow in river_live\n", " if day <= today and flow is not None][-1]\n", " ratio = latest_flow / usual\n", " river_live_score = ramp(ratio, 1.5, 3.0)\n", " print(f\"usual flow this month {usual:.0f} m3/s, on {latest_day} {latest_flow:.0f} m3/s \"\n", " f\"= {ratio:.2f} times usual -> river score {river_live_score:.2f}\")\n", "except Exception as problem:\n", " river_live_score = None\n", " print(\"no live river data:\", problem)" ] }, { "cell_type": "code", "execution_count": 20, "id": "977c5046", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:27.553977Z", "iopub.status.busy": "2026-10-01T07:03:27.553977Z", "iopub.status.idle": "2026-10-01T07:03:28.795812Z", "shell.execute_reply": "2026-10-01T07:03:28.795812Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "129 earthquakes of magnitude 4.5 or more in the last 7 days\n", "nearest to Chiang Mai: M4.5 78 km N of Daocheng, China, 2026-09-27 18:30 UTC, 1225 km away\n", " shaking here by the rule 1.0, warning 163 s, score 0.00\n" ] } ], "source": [ "try:\n", " recent = live_data.quakes(hours=24 * 7, min_magnitude=4.5)\n", " print(len(recent), \"earthquakes of magnitude 4.5 or more in the last 7 days\")\n", " nearest = min(recent, key=lambda q: distance_km(*CHIANG_MAI, q[\"lat\"], q[\"lon\"]))\n", " km = distance_km(*CHIANG_MAI, nearest[\"lat\"], nearest[\"lon\"])\n", " print(f\"nearest to Chiang Mai: M{nearest['magnitude']} {nearest['place']}, \"\n", " f\"{nearest['time']}, {km:.0f} km away\")\n", " print(f\" shaking here by the rule {intensity(nearest['magnitude'], km):.1f}, \"\n", " f\"warning {warning_seconds(km):.0f} s, score {shake_score(nearest['magnitude'], km):.2f}\")\n", "except Exception as problem:\n", " print(\"no live earthquake data:\", problem)" ] }, { "cell_type": "code", "execution_count": 21, "id": "1815c83c", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:28.795812Z", "iopub.status.busy": "2026-10-01T07:03:28.795812Z", "iopub.status.idle": "2026-10-01T07:03:32.744051Z", "shell.execute_reply": "2026-10-01T07:03:32.744051Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "73 events reported in 30 days; 1 within 600 km of Chiang Mai:\n", " 2026-10-04 Floods Flood in Thailand 1104169\n", "best match for 'flood in Thailand': 2 shared -> Flood in Thailand 1104169\n" ] } ], "source": [ "try:\n", " reported = live_data.events(days=30)\n", " near = [e for e in reported if distance_km(*CHIANG_MAI, e[\"lat\"], e[\"lon\"]) < 600]\n", " print(len(reported), \"events reported in 30 days;\", len(near), \"within 600 km of Chiang Mai:\")\n", " for e in near[:8]:\n", " print(f\" {e['date']} {e['kind']:14} {e['title']}\")\n", " live_archive = [{\"year\": int(e[\"date\"][:4]), \"kind\": e[\"kind\"].lower(),\n", " \"place\": e[\"title\"], \"text\": e[\"title\"] + \" \" + e[\"date\"]} for e in reported]\n", " best = search(\"flood in Thailand\", live_archive)[0]\n", " print(\"best match for 'flood in Thailand':\", best[0], \"shared ->\", best[1][\"place\"])\n", " archive_live = best[0]\n", "except Exception as problem:\n", " archive_live = None\n", " print(\"no live event data:\", problem)" ] }, { "cell_type": "markdown", "id": "32fcce64", "metadata": {}, "source": [ "### Today's alert\n", "\n", "Put the live signals through the same coordinator. The satellite has no free live source,\n", "so it is `None` — and a missing signal changes nothing, by design. Run this cell on a wet\n", "day in September and on a dry day in February and compare." ] }, { "cell_type": "code", "execution_count": 22, "id": "9eb35a83", "metadata": { "execution": { "iopub.execute_input": "2026-10-01T07:03:32.744051Z", "iopub.status.busy": "2026-10-01T07:03:32.744051Z", "iopub.status.idle": "2026-10-01T07:03:32.757597Z", "shell.execute_reply": "2026-10-01T07:03:32.757597Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rain: wettest of the past week 51.5 mm, wettest forecast 20.0 mm\n", " rain score 0.53 odds x1.12\n", " rain score 0.00 odds x0.10\n", " satellite score 0.50 odds x1.00\n", " archive score 0.33 odds x0.46\n", " river score 0.00 odds x0.10\n", "2026-10-01: chance of a flood soon 0% -> GREEN - calm\n" ] } ], "source": [ "try:\n", " rain_now = max(mm for day, mm in rain_live if day <= today) # the wettest recent day\n", " rain_next = max(mm for day, mm in rain_live if day > today) # the wettest forecast day\n", " print(f\"rain: wettest of the past week {rain_now:.1f} mm, wettest forecast {rain_next:.1f} mm\")\n", " # two rain signals: the rain that fell, and the rain that is forecast\n", " live_signals = [Signal(\"rain\", rain_now), Signal(\"rain\", rain_next),\n", " Signal(\"satellite\", None), Signal(\"archive\", archive_live)]\n", " if river_live_score is not None:\n", " live_signals.append(Signal(\"river\", 3.0 + 0.7 * river_live_score)) # a score, as metres\n", " for signal in live_signals:\n", " print(f\" {signal.kind:10} score {signal.score():.2f} odds x{signal.weight():.2f}\")\n", " chance = fuse(live_signals, PRIOR)\n", " print(f\"{today}: chance of a flood soon {chance:.0%} -> {decide(chance, 0.5)}\")\n", "except Exception as problem:\n", " print(\"the live alert needs the cells above:\", problem)" ] }, { "cell_type": "markdown", "id": "3d0e871b", "metadata": {}, "source": [ "Look at what you just did. The river line turns a *score* back into metres (`3.0 + 0.7 * score`)\n", "only so that the same `Signal(\"river\", ...)` can read it — a small trick that keeps one class\n", "for every signal. In a real system you would write a sixth scorer instead. That is your first challenge." ] }, { "cell_type": "markdown", "id": "49f40ca6", "metadata": {}, "source": [ "## 12 · Challenges\n", "\n", "1. **A sixth scorer.** Add `\"flow\"` to `SCORERS`: a function that takes the GloFAS ratio and\n", " returns `ramp(ratio, 1.5, 3.0)`. Then use `Signal(\"flow\", ratio)` in the live alert.\n", "2. **A better forecast.** Make `forecast()` use the average climb of the last three days.\n", " Does the worst day in section 5 get better or worse?\n", "3. **Your province.** Change `CHIANG_MAI` to the latitude and longitude of your town and run\n", " section 11 again. `live_data.rain_days((lat, lon))` works for anywhere on Earth.\n", "4. **The real rain.** Run `evaluate()` with `RAIN_ERA5` instead of `RAIN`. Which threshold is\n", " best now?\n", "5. **The seismometer.** Use `live_data.quakes(hours=24 * 30, min_magnitude=6)` and print, for\n", " each one, how many seconds of warning Chiang Mai would have had.\n", "6. **A new archive.** Build an archive from `live_data.events(days=60)` and search it with\n", " three different sentences. Which words matter? Which do not?\n", "7. **Save your work.** Put the functions you wrote into a file called `my_agent.py` with a\n", " `main()`, and run it from a terminal with `python my_agent.py`.\n", "\n", "Thank you for working through it. Open the machines on the page, say what you see, and see\n", "you in the next lab." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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 }