{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c4af8bf4",
   "metadata": {},
   "source": [
    "# 第 16 章　自編碼器與生成模型 — 實作 Notebook\n",
    "\n",
    "「醫學生的機器學習入門」深度學習篇第 16 章配套程式（網站：<https://med-study-rpg.com/ml/chapters/16-generative/>）。建議在 **Google Colab** 執行（「執行階段 → 全部執行」）；本機 Jupyter 需安裝 `tensorflow` 與 `keras`。\n",
    "\n",
    "本 notebook 做一件事：**只給模型看正常心搏，讓它學會「正常長什麼樣」，再用「還原得像不像」來抓異常心搏。**\n",
    "\n",
    "1. 從 PhysioNet 官方下載 MIT-BIH Arrhythmia Database，切出心搏（和第 14 章同一套程式）\n",
    "2. **依受試者**切成三組：訓練（只取其中的正常心搏）、驗證（用來定閾值）、測試（全部心搏，含異常）\n",
    "3. 先用第 10 章的 PCA 做「線性版」的壓縮與還原，當作基準\n",
    "4. 訓練一個小型自編碼器（autoencoder），以重建誤差當異常分數，選閾值、算敏感度與特異度、AUC\n",
    "5. 把 8 維的潛在空間畫成 2D；重做一次「隨機切心搏」，看資料洩漏會讓成績虛高多少\n",
    "6. 延伸實驗（可跳過）：換潛在維度、換隨機種子、換測試折，看結果有多穩定\n",
    "\n",
    "時間：本機筆電 CPU 實測約 1 分鐘（不含下載）。第 9 節延伸實驗要再訓練 11 個模型，本機約佔 45 秒，Colab 免費 CPU 上較久：**建議開 GPU，也可以跳過**（跳過後其餘各格照常可跑）。\n",
    "\n",
    "資料：MIT-BIH Arrhythmia Database（Moody & Mark 2001；PhysioNet），授權 Open Data Commons Attribution License v1.0（ODC-By）。本 notebook 的結果僅供學習，不構成臨床建議。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a9a3ccd",
   "metadata": {},
   "source": [
    "## 0. 環境檢查\n",
    "印出套件版本並固定隨機種子。Keras 要在 `import` 之前用環境變數指定後端（backend）。沒有 Keras 的環境會跳過自編碼器段落（PCA 基準仍可執行）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0eb5971f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:40.557122Z",
     "iopub.status.busy": "2026-10-06T23:30:40.556949Z",
     "iopub.status.idle": "2026-10-06T23:30:43.312092Z",
     "shell.execute_reply": "2026-10-06T23:30:43.311643Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy 2.1.3 | pandas 2.2.3 | scipy 1.16.3 | scikit-learn 1.6.1 | matplotlib 3.10.0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "keras 3.13.2 | backend: tensorflow\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import time\n",
    "import json\n",
    "import zipfile\n",
    "import hashlib\n",
    "import urllib.request\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import sklearn\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import butter, filtfilt\n",
    "from sklearn.model_selection import StratifiedKFold, StratifiedGroupKFold, GroupShuffleSplit\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "# Some numpy builds on macOS (Apple Accelerate) print spurious \"encountered in matmul\"\n",
    "# RuntimeWarnings inside PCA; results are unaffected and Colab (Linux) does not show them.\n",
    "if sys.platform == \"darwin\":\n",
    "    import warnings\n",
    "    warnings.filterwarnings(\"ignore\", message=\".*encountered in matmul\", category=RuntimeWarning)\n",
    "\n",
    "print(\"numpy\", np.__version__, \"| pandas\", pd.__version__, \"| scipy\", scipy.__version__,\n",
    "      \"| scikit-learn\", sklearn.__version__, \"| matplotlib\", matplotlib.__version__)\n",
    "RS = 42\n",
    "T_START = time.time()\n",
    "\n",
    "os.environ[\"KERAS_BACKEND\"] = \"tensorflow\"   # must be set before importing keras\n",
    "try:\n",
    "    import keras\n",
    "    keras.utils.set_random_seed(RS)          # results may still differ slightly across hardware\n",
    "    print(\"keras\", keras.__version__, \"| backend:\", keras.backend.backend())\n",
    "except ImportError:\n",
    "    keras = None\n",
    "    print(\"Keras is not installed in this environment -> autoencoder sections will be skipped.\")\n",
    "    print(\"Run this notebook on Google Colab, or `pip install tensorflow keras` locally.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53f5e5f9",
   "metadata": {},
   "source": [
    "## 1. 從官方來源下載原始資料（同第 14 章）\n",
    "\n",
    "MIT-BIH Arrhythmia Database：48 段、每段 30 分鐘的雙導程 Holter 心電圖，360 Hz，來自 47 位受試者（**record 201 與 202 是同一人**）。依 AAMI 慣例排除 4 段節律器紀錄，剩 44 段、43 位受試者。\n",
    "\n",
    "下載策略和第 14 章相同：**方案 A** PhysioNet 官方 zip（77 MB，用 zip 內附的 `SHA256SUMS.txt` 檢查）→ **方案 B** 官方網址逐檔下載 → **方案 C** Hugging Face 第三方鏡像（只在官方都失敗時用）。如果你在同一個 Colab 工作階段跑過第 14 章，`data/mitdb.zip` 已存在就不會重抓。（本檔存著的輸出是用先前從 PhysioNet 下載、已比對官方 SHA256 的 zip 執行的，所以顯示 no download needed；你在 Colab 執行時會實際下載。）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ca743c6f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:43.313209Z",
     "iopub.status.busy": "2026-10-06T23:30:43.313091Z",
     "iopub.status.idle": "2026-10-06T23:30:43.316884Z",
     "shell.execute_reply": "2026-10-06T23:30:43.316561Z"
    }
   },
   "outputs": [],
   "source": [
    "DATA_DIR = \"data\"\n",
    "os.makedirs(DATA_DIR, exist_ok=True)\n",
    "ZIP_URL = \"https://physionet.org/static/published-projects/mitdb/mit-bih-arrhythmia-database-1.0.0.zip\"\n",
    "FILE_URL = \"https://physionet.org/files/mitdb/1.0.0/\"\n",
    "HF_URL = (\"https://huggingface.co/datasets/epr-labs/mit-bih-arrhythmia-database/\"\n",
    "          \"resolve/main/data/train-00000-of-00001.parquet\")\n",
    "ZIP_PATH = os.path.join(DATA_DIR, \"mitdb.zip\")\n",
    "\n",
    "# 44 non-paced records (AAMI convention drops paced records 102, 104, 107, 217)\n",
    "RECORDS = '''100 101 103 105 106 108 109 111 112 113 114 115 116 117 118 119 121 122 123 124\n",
    "200 201 202 203 205 207 208 209 210 212 213 214 215 219 220 221 222 223 228 230 231 232 233 234'''.split()\n",
    "SUBJECT = {r: (\"201\" if r == \"202\" else r) for r in RECORDS}   # records 201 and 202 = same person\n",
    "\n",
    "\n",
    "def plan_a_zip():\n",
    "    \"\"\"Official PhysioNet zip (77 MB). Returns a function name -> file bytes.\"\"\"\n",
    "    if not (os.path.exists(ZIP_PATH) and zipfile.is_zipfile(ZIP_PATH)):   # skip half-downloaded files\n",
    "        print(\"downloading the official zip (77 MB) from physionet.org ...\")\n",
    "        urllib.request.urlretrieve(ZIP_URL, ZIP_PATH + \".part\")\n",
    "        os.replace(ZIP_PATH + \".part\", ZIP_PATH)\n",
    "    else:\n",
    "        print(\"found\", ZIP_PATH, \"-> no download needed\")\n",
    "    z = zipfile.ZipFile(ZIP_PATH)\n",
    "    root = z.namelist()[0].split(\"/\")[0]\n",
    "    # integrity check: the zip ships its own SHA256SUMS.txt\n",
    "    sums = dict(line.split()[::-1] for line in z.read(f\"{root}/SHA256SUMS.txt\").decode().splitlines() if line)\n",
    "    for r in RECORDS:\n",
    "        for ext in (\".hea\", \".dat\", \".atr\"):\n",
    "            assert hashlib.sha256(z.read(f\"{root}/{r}{ext}\")).hexdigest() == sums[r + ext], r + ext\n",
    "    print(\"SHA-256 of all\", 3 * len(RECORDS), \"files match SHA256SUMS.txt\")\n",
    "    return lambda name: z.read(f\"{root}/{name}\")\n",
    "\n",
    "\n",
    "def plan_b_files():\n",
    "    \"\"\"Official PhysioNet per-file download (132 small requests).\"\"\"\n",
    "    folder = os.path.join(DATA_DIR, \"mitdb_files\")\n",
    "    os.makedirs(folder, exist_ok=True)\n",
    "    for r in RECORDS:\n",
    "        for ext in (\".hea\", \".dat\", \".atr\"):\n",
    "            path = os.path.join(folder, r + ext)\n",
    "            if not os.path.exists(path):\n",
    "                urllib.request.urlretrieve(FILE_URL + r + ext, path + \".part\")\n",
    "                os.replace(path + \".part\", path)   # never reuse a half-downloaded file\n",
    "    print(\"downloaded\", 3 * len(RECORDS), \"files from\", FILE_URL)\n",
    "    return lambda name: open(os.path.join(folder, name), \"rb\").read()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dd04349",
   "metadata": {},
   "source": [
    "WFDB 格式讀檔器（`.hea` 標頭、`.dat` 訊號、`.atr` 標註），和第 14 章完全相同。**你不需要看懂這一格**，它讀出來的東西和官方 `wfdb` 套件一樣。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "46ba068c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:43.317907Z",
     "iopub.status.busy": "2026-10-06T23:30:43.317843Z",
     "iopub.status.idle": "2026-10-06T23:30:44.065752Z",
     "shell.execute_reply": "2026-10-06T23:30:44.065395Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found data/mitdb.zip -> no download needed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SHA-256 of all 132 files match SHA256SUMS.txt\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44 records loaded in 0.7 s (download + reading)\n"
     ]
    }
   ],
   "source": [
    "BEAT_CODES = {1: \"N\", 2: \"L\", 3: \"R\", 4: \"a\", 5: \"V\", 6: \"F\", 7: \"J\", 8: \"A\", 9: \"S\",\n",
    "              10: \"E\", 11: \"j\", 12: \"/\", 13: \"Q\", 34: \"e\", 38: \"f\"}   # MIT annotation codes\n",
    "\n",
    "\n",
    "def read_header(text):\n",
    "    lines = [l for l in text.splitlines() if l.strip() and not l.startswith(\"#\")]\n",
    "    n_sig, fs = int(lines[0].split()[1]), float(lines[0].split()[2])\n",
    "    sigs = []\n",
    "    for l in lines[1:1 + n_sig]:\n",
    "        p = l.split()\n",
    "        sigs.append({\"gain\": float(p[2].split(\"/\")[0].split(\"(\")[0]), \"adc_zero\": int(p[4]), \"name\": p[-1]})\n",
    "    return n_sig, fs, sigs\n",
    "\n",
    "\n",
    "def read_212(raw, n_sig):\n",
    "    b = np.frombuffer(raw, dtype=np.uint8).reshape(-1, 3).astype(np.int16)\n",
    "    s0 = b[:, 0] | ((b[:, 1] & 0x0F) << 8)          # 12-bit sample 1\n",
    "    s1 = b[:, 2] | ((b[:, 1] & 0xF0) << 4)          # 12-bit sample 2\n",
    "    d = np.stack([s0, s1], axis=1).reshape(-1, n_sig)\n",
    "    d[d > 2047] -= 4096                             # two's complement\n",
    "    return d\n",
    "\n",
    "\n",
    "def read_atr(raw):\n",
    "    w = np.frombuffer(raw, dtype=\"<u2\")\n",
    "    samples, symbols, t, i = [], [], 0, 0\n",
    "    while i < len(w):\n",
    "        code, inc = int(w[i]) >> 10, int(w[i]) & 0x3FF\n",
    "        if code == 0 and inc == 0:                  # end of file\n",
    "            break\n",
    "        if code == 59:                              # SKIP: long time jump\n",
    "            t += int(np.int32((int(w[i + 1]) << 16) | int(w[i + 2])))\n",
    "            i += 3\n",
    "        elif code == 63:                            # AUX: text attached to the previous label\n",
    "            i += 1 + (inc + 1) // 2\n",
    "        elif code in (60, 61, 62):                  # NUM / SUB / CHN fields\n",
    "            i += 1\n",
    "        else:\n",
    "            t += inc\n",
    "            samples.append(t)\n",
    "            symbols.append(BEAT_CODES.get(code, \"?\"))   # \"?\" = non-beat label (rhythm, noise...)\n",
    "            i += 1\n",
    "    return np.array(samples), np.array(symbols)\n",
    "\n",
    "\n",
    "def read_records(get_bytes):\n",
    "    \"\"\"Return {record: (fs, MLII signal in mV, annotation samples, annotation symbols)}.\"\"\"\n",
    "    out = {}\n",
    "    for r in RECORDS:\n",
    "        n_sig, fs, sigs = read_header(get_bytes(r + \".hea\").decode())\n",
    "        k = [s[\"name\"] for s in sigs].index(\"MLII\")       # record 114 stores MLII as the 2nd lead\n",
    "        dig = read_212(get_bytes(r + \".dat\"), n_sig)[:, k]\n",
    "        samp, sym = read_atr(get_bytes(r + \".atr\"))\n",
    "        out[r] = (fs, (dig - sigs[k][\"adc_zero\"]) / sigs[k][\"gain\"], samp, sym)\n",
    "    return out\n",
    "\n",
    "\n",
    "def plan_c_mirror():\n",
    "    \"\"\"Fallback: third-party Hugging Face mirror of the same raw files (ODC-By); needs pyarrow.\"\"\"\n",
    "    import json\n",
    "    path = os.path.join(DATA_DIR, \"mitdb_hf.parquet\")\n",
    "    if not os.path.exists(path):\n",
    "        urllib.request.urlretrieve(HF_URL, path)\n",
    "    out = {}\n",
    "    for _, row in pd.read_parquet(path).iterrows():\n",
    "        h = json.loads(row[\"header\"])\n",
    "        if h[\"record_name\"] in RECORDS:\n",
    "            k = h[\"sig_name\"].index(\"MLII\")\n",
    "            out[h[\"record_name\"]] = (float(h[\"fs\"]), np.stack(row[\"signals\"])[:, k].astype(float),\n",
    "                                     np.asarray(row[\"annotation_sample\"]), np.asarray(row[\"annotation_symbol\"]))\n",
    "    print(\"loaded from the Hugging Face mirror\")\n",
    "    return out\n",
    "\n",
    "\n",
    "t0 = time.time()\n",
    "records = None\n",
    "for plan in (lambda: read_records(plan_a_zip()), lambda: read_records(plan_b_files()), plan_c_mirror):\n",
    "    try:\n",
    "        records = plan()\n",
    "        break\n",
    "    except Exception as e:\n",
    "        print(\"download plan failed:\", repr(e)[:200], \"-> trying the next one\")\n",
    "assert records is not None and len(records) == len(RECORDS), (\n",
    "    \"All download plans failed. Check your internet connection, or download the zip manually from \"\n",
    "    \"https://physionet.org/content/mitdb/1.0.0/ and put it at data/mitdb.zip\")\n",
    "T_LOAD = time.time() - t0\n",
    "print(f\"{len(records)} records loaded in {T_LOAD:.1f} s (download + reading)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d260c28a",
   "metadata": {},
   "source": [
    "## 2. 切心搏、對應到 AAMI 類別（同第 14 章）\n",
    "\n",
    "帶通濾波 0.5–40 Hz → 每段紀錄各自標準化 → 以 R 峰為中心切 R 峰前 0.25 秒到後 0.40 秒，每 2 點取 1 點，每個心搏 117 個數字。類別依 AAMI 合併為 N（正常類，**包含束支傳導阻滯**）、S、V、F；Q 類 15 個排除。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2d196482",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:44.066969Z",
     "iopub.status.busy": "2026-10-06T23:30:44.066910Z",
     "iopub.status.idle": "2026-10-06T23:30:44.551372Z",
     "shell.execute_reply": "2026-10-06T23:30:44.550977Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X shape: (100680, 117, 1) | prepared in 0.5 s | Q beats excluded: 15\n",
      "   beats  percent\n",
      "N  90089    89.48\n",
      "S   2781     2.76\n",
      "V   7008     6.96\n",
      "F    802     0.80\n"
     ]
    }
   ],
   "source": [
    "AAMI = {**dict.fromkeys(\"NLRej\", \"N\"), **dict.fromkeys(\"AaJS\", \"S\"),\n",
    "        **dict.fromkeys(\"VE\", \"V\"), \"F\": \"F\", **dict.fromkeys(\"fQ\", \"Q\")}\n",
    "CLASSES = [\"N\", \"S\", \"V\", \"F\"]\n",
    "PRE, POST, STEP = 90, 144, 2          # 0.25 s before / 0.40 s after the R peak at 360 Hz; keep every 2nd point\n",
    "\n",
    "t0 = time.time()\n",
    "X, y, groups, n_q = [], [], [], 0\n",
    "for r, (fs, sig, samp, sym) in records.items():\n",
    "    assert fs == 360\n",
    "    b, a = butter(2, [0.5, 40], btype=\"band\", fs=fs)\n",
    "    sig = filtfilt(b, a, sig)\n",
    "    sig = (sig - sig.mean()) / sig.std()          # per-record standardisation\n",
    "    for s, label in zip(samp, sym):\n",
    "        if label in AAMI and PRE <= s < len(sig) - POST:\n",
    "            if AAMI[label] == \"Q\":\n",
    "                n_q += 1\n",
    "                continue\n",
    "            X.append(sig[s - PRE:s + POST:STEP])\n",
    "            y.append(CLASSES.index(AAMI[label]))\n",
    "            groups.append(SUBJECT[r])\n",
    "X = np.array(X, dtype=\"float32\")[..., None]       # (n_beats, 117 time points, 1 channel) for Conv1D\n",
    "y, groups = np.array(y), np.array(groups)\n",
    "T_PREP = time.time() - t0\n",
    "\n",
    "counts = np.bincount(y, minlength=4)\n",
    "assert counts.sum() == len(y) == len(X)           # class counts add up to the total number of beats\n",
    "assert len(set(groups)) == 43                     # 44 records, 201 + 202 merged into one subject\n",
    "print(\"X shape:\", X.shape, f\"| prepared in {T_PREP:.1f} s | Q beats excluded: {n_q}\")\n",
    "print(pd.DataFrame({\"beats\": counts, \"percent\": (100 * counts / counts.sum()).round(2)}, index=CLASSES))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "721628fc",
   "metadata": {},
   "source": [
    "## 3. 依受試者切成三組\n",
    "\n",
    "這一章是**非監督式**的異常偵測：訓練時只給模型看正常心搏（N 類），不給任何異常心搏的標籤。但評估時仍要知道答案，才能算敏感度與特異度。\n",
    "\n",
    "切法延續第 14 章的教訓——**以受試者為單位**，同一個人只會出現在一組：\n",
    "\n",
    "- **測試組**：`StratifiedGroupKFold` 的第 1 折，就是第 14 章「切法 B」第 1 折的那 15 位受試者。保留**全部**心搏（含異常），比例不動。\n",
    "- 剩下 28 位再用 `GroupShuffleSplit` 分成 **訓練組**（約 3/4 的人，只取 N 類心搏來訓練）與 **驗證組**（約 1/4 的人，只用 N 類心搏來**定閾值**）。\n",
    "\n",
    "閾值用驗證組決定、不碰測試組，測試組只在最後評估一次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "72e68a5d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:44.552604Z",
     "iopub.status.busy": "2026-10-06T23:30:44.552527Z",
     "iopub.status.idle": "2026-10-06T23:30:44.594655Z",
     "shell.execute_reply": "2026-10-06T23:30:44.594308Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                     subjects  beats used      N     S     V    F\n",
      "train (N only)             21       45184  45184     0     0    0\n",
      "validation (N only)         7       15407  15407     0     0    0\n",
      "test (all beats)           15       33421  29498  1463  2072  388\n",
      "test subjects: 100, 103, 106, 111, 112, 114, 115, 117, 122, 208, 210, 212, 214, 219, 232\n"
     ]
    }
   ],
   "source": [
    "tr, te = next(StratifiedGroupKFold(3, shuffle=True, random_state=RS).split(X, y, groups))\n",
    "fit_i, val_i = next(GroupShuffleSplit(n_splits=1, test_size=0.25, random_state=RS).split(tr, groups=groups[tr]))\n",
    "fit, val = tr[fit_i], tr[val_i]\n",
    "S_fit, S_val, S_te = set(groups[fit]), set(groups[val]), set(groups[te])\n",
    "\n",
    "# no subject in two groups; every beat in exactly one group\n",
    "assert not (S_fit & S_val) and not (S_fit & S_te) and not (S_val & S_te)\n",
    "assert len(S_fit) + len(S_val) + len(S_te) == 43\n",
    "assert len(fit) + len(val) + len(te) == len(y)\n",
    "\n",
    "fit_n = fit[y[fit] == 0]          # training: normal beats only\n",
    "val_n = val[y[val] == 0]          # validation: normal beats only, used to set the threshold\n",
    "is_abn = y[te] != 0               # test: 1 = S/V/F (abnormal), 0 = N\n",
    "X2 = X[:, :, 0]                   # (n_beats, 117) for PCA and the dense autoencoder\n",
    "\n",
    "split_table = pd.DataFrame({\n",
    "    \"subjects\": [len(S_fit), len(S_val), len(S_te)],\n",
    "    \"beats used\": [len(fit_n), len(val_n), len(te)],\n",
    "    \"N\": [len(fit_n), len(val_n), int((y[te] == 0).sum())],\n",
    "    \"S\": [0, 0, int((y[te] == 1).sum())], \"V\": [0, 0, int((y[te] == 2).sum())],\n",
    "    \"F\": [0, 0, int((y[te] == 3).sum())]},\n",
    "    index=[\"train (N only)\", \"validation (N only)\", \"test (all beats)\"])\n",
    "assert (split_table[[\"N\", \"S\", \"V\", \"F\"]].sum(axis=1) == split_table[\"beats used\"]).all()\n",
    "print(split_table)\n",
    "print(\"test subjects:\", \", \".join(sorted(map(str, S_te))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "821da050",
   "metadata": {},
   "source": [
    "## 4. 基準：PCA 也是一種「壓縮＋還原」\n",
    "\n",
    "第 10 章的主成分分析（PCA）把 117 維的心搏投影到幾個主成分上（壓縮），再用 `inverse_transform` 投影回 117 維（還原）。還原得越不像，代表這個心搏越不符合「訓練資料的主要變化方向」。\n",
    "\n",
    "這裡用 8 個主成分，和等一下自編碼器的 8 維潛在空間對齊。重建誤差（reconstruction error）定義為每個心搏 117 個點的均方誤差（mean squared error, MSE）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7e2782a7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:44.595823Z",
     "iopub.status.busy": "2026-10-06T23:30:44.595763Z",
     "iopub.status.idle": "2026-10-06T23:30:44.613723Z",
     "shell.execute_reply": "2026-10-06T23:30:44.613410Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "variance explained by 8 components: 0.915\n"
     ]
    }
   ],
   "source": [
    "LATENT = 8\n",
    "pca = PCA(n_components=LATENT, random_state=RS).fit(X2[fit_n])     # fit on training normal beats only\n",
    "\n",
    "\n",
    "def pca_error(idx):\n",
    "    rec = pca.inverse_transform(pca.transform(X2[idx]))\n",
    "    return np.mean((rec - X2[idx]) ** 2, axis=1)\n",
    "\n",
    "\n",
    "print(f\"variance explained by {LATENT} components: {pca.explained_variance_ratio_.sum():.3f}\")\n",
    "err_val_pca, err_te_pca = pca_error(val_n), pca_error(te)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8c79153",
   "metadata": {},
   "source": [
    "## 5. 自編碼器：編碼器 → 8 維瓶頸 → 解碼器\n",
    "\n",
    "自編碼器是一個「輸出要等於輸入」的神經網路。中間故意做一個很窄的瓶頸（bottleneck），逼網路只能用 8 個數字記住一個 117 點的心搏：\n",
    "\n",
    "- **編碼器（encoder）**：117 → 64 → 32 → 8（壓縮）\n",
    "- **解碼器（decoder）**：8 → 32 → 64 → 117（還原）\n",
    "\n",
    "訓練目標就是讓輸出和輸入的 MSE 越小越好，**不需要任何標籤**。如果把所有 ReLU 拿掉、只剩線性層，最佳解會和 PCA 張出同一個子空間；加上非線性之後，它可以學到彎曲的結構。\n",
    "\n",
    "**選模的揭露**：訓練本身只用正常心搏；但潛在維度 8 是寫作時在 2、4、8、16 之中，用**驗證組受試者的 AUC** 挑的——算 AUC 需要驗證組受試者的異常心搏與標籤。測試組沒有參與**這一步**。但要誠實說明：寫作初期還試過較窄的網路、40 個 epoch 與一維卷積版本，當時也看過它們的測試組 AUC（那些設定沒有放進本 notebook）。看過測試組再決定設定，最後的數字對「沒看過的新病人」會偏樂觀。真實研究的做法是把測試集鎖起來，所有設定都定案後才打開一次。第 9 節的延伸實驗把四種潛在維度在驗證組與測試組的結果都列出來。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7b4e8347",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:44.614812Z",
     "iopub.status.busy": "2026-10-06T23:30:44.614750Z",
     "iopub.status.idle": "2026-10-06T23:30:48.607996Z",
     "shell.execute_reply": "2026-10-06T23:30:48.607538Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameters: 19,901 | trained on 45,184 normal beats in 3.9 s\n",
      "final MSE  training subjects 0.0172 | validation subjects 0.0800\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 20\n",
    "\n",
    "\n",
    "def build_autoencoder(latent=LATENT):\n",
    "    encoder = keras.Sequential([\n",
    "        keras.Input(shape=(X2.shape[1],)),\n",
    "        keras.layers.Dense(64, activation=\"relu\"),\n",
    "        keras.layers.Dense(32, activation=\"relu\"),\n",
    "        keras.layers.Dense(latent),                      # the bottleneck: 8 numbers per beat\n",
    "    ], name=\"encoder\")\n",
    "    decoder = keras.Sequential([\n",
    "        keras.Input(shape=(latent,)),\n",
    "        keras.layers.Dense(32, activation=\"relu\"),\n",
    "        keras.layers.Dense(64, activation=\"relu\"),\n",
    "        keras.layers.Dense(X2.shape[1]),                 # back to 117 points\n",
    "    ], name=\"decoder\")\n",
    "    ae = keras.Sequential([encoder, decoder], name=\"autoencoder\")\n",
    "    ae.compile(optimizer=keras.optimizers.Adam(learning_rate=1e-3), loss=\"mse\")\n",
    "    return encoder, ae\n",
    "\n",
    "\n",
    "def train_autoencoder(train_idx, val_idx, seed=RS, latent=LATENT):\n",
    "    keras.utils.set_random_seed(seed)\n",
    "    encoder, ae = build_autoencoder(latent)\n",
    "    t = time.time()\n",
    "    hist = ae.fit(X2[train_idx], X2[train_idx], epochs=EPOCHS, batch_size=256, verbose=0,\n",
    "                  validation_data=(X2[val_idx], X2[val_idx]))   # input = target: no labels needed\n",
    "    return encoder, ae, hist, time.time() - t\n",
    "\n",
    "\n",
    "def ae_error(ae, idx):\n",
    "    rec = ae.predict(X2[idx], batch_size=4096, verbose=0)\n",
    "    return np.mean((rec - X2[idx]) ** 2, axis=1)\n",
    "\n",
    "\n",
    "if keras is not None:\n",
    "    encoder, ae, hist, t_train = train_autoencoder(fit_n, val_n)\n",
    "    print(f\"parameters: {ae.count_params():,} | trained on {len(fit_n):,} normal beats in {t_train:.1f} s\")\n",
    "    print(f\"final MSE  training subjects {hist.history['loss'][-1]:.4f} | \"\n",
    "          f\"validation subjects {hist.history['val_loss'][-1]:.4f}\")\n",
    "    err_val_ae, err_te_ae = ae_error(ae, val_n), ae_error(ae, te)\n",
    "else:\n",
    "    print(\"Skipped: Keras is not available.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90c5dbd0",
   "metadata": {},
   "source": [
    "注意最後一行：訓練組受試者的 MSE 明顯低於驗證組受試者。模型對「見過的人」的正常心搏還原得特別好，換成沒見過的人就差一截——這正是第 14 章資料洩漏問題的另一面。\n",
    "\n",
    "### 5.1 看幾個還原的例子\n",
    "從測試組各挑一個 N、S、V 心搏，畫出原始波形與自編碼器的還原。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a07b6c1d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:48.609280Z",
     "iopub.status.busy": "2026-10-06T23:30:48.609212Z",
     "iopub.status.idle": "2026-10-06T23:30:48.775003Z",
     "shell.execute_reply": "2026-10-06T23:30:48.774670Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if keras is not None:\n",
    "    rng = np.random.default_rng(RS)\n",
    "    fig, axes = plt.subplots(1, 3, figsize=(12, 3), sharey=True)\n",
    "    t_ms = (np.arange(X2.shape[1]) * STEP - PRE) / 360 * 1000\n",
    "    for ax, k in zip(axes, [0, 1, 2]):\n",
    "        i = rng.choice(np.where(y[te] == k)[0])\n",
    "        rec = ae.predict(X2[te[i]][None], verbose=0)[0]\n",
    "        ax.plot(t_ms, X2[te[i]], color=\"#607D8B\", lw=2, label=\"original\")\n",
    "        ax.plot(t_ms, rec, color=\"#F4511E\", lw=1.5, ls=\"--\", label=\"reconstruction\")\n",
    "        ax.set_title(f\"{CLASSES[k]} beat, error = {err_te_ae[i]:.3f}\")\n",
    "        ax.set_xlabel(\"ms from R peak\")\n",
    "    axes[0].set_ylabel(\"standardised amplitude\")\n",
    "    axes[0].legend()\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d93a4bca",
   "metadata": {},
   "source": [
    "## 6. 重建誤差當異常分數：閾值、敏感度、特異度\n",
    "\n",
    "重建誤差就是一個「異常分數」：分數越高越可疑。要變成「判異常／判正常」的決定，就需要一個**閾值**（第 11 章的老朋友）。\n",
    "\n",
    "這裡的做法：取**驗證組正常心搏**重建誤差的第 95 百分位數當閾值，也就是「預期約 5% 的正常心搏會被誤判」，目標特異度約 95%。AUC 則不需要閾值，看的是整體排序能力。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "44fc31b1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:48.776454Z",
     "iopub.status.busy": "2026-10-06T23:30:48.776371Z",
     "iopub.status.idle": "2026-10-06T23:30:48.786684Z",
     "shell.execute_reply": "2026-10-06T23:30:48.786299Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test beats: 33,421 (3,923 abnormal, 29,498 normal)\n",
      "             PCA (8 components)  autoencoder (8-d)\n",
      "threshold                 0.190              0.246\n",
      "auc                       0.775              0.783\n",
      "sensitivity               0.223              0.249\n",
      "specificity               0.942              0.945\n",
      "sens_S                    0.019              0.011\n",
      "sens_V                    0.401              0.458\n",
      "sens_F                    0.039              0.031\n"
     ]
    }
   ],
   "source": [
    "def evaluate(err_val, err_te, q=0.95):\n",
    "    thr = np.quantile(err_val, q)\n",
    "    flag = err_te > thr\n",
    "    out = {\"threshold\": float(thr), \"auc\": roc_auc_score(is_abn, err_te),\n",
    "           \"sensitivity\": flag[is_abn].mean(), \"specificity\": (~flag[~is_abn]).mean()}\n",
    "    for k, c in enumerate(CLASSES[1:], start=1):\n",
    "        out[f\"sens_{c}\"] = flag[y[te] == k].mean()\n",
    "    return out\n",
    "\n",
    "\n",
    "res = {\"PCA (8 components)\": evaluate(err_val_pca, err_te_pca)}\n",
    "if keras is not None:\n",
    "    res[\"autoencoder (8-d)\"] = evaluate(err_val_ae, err_te_ae)\n",
    "print(f\"test beats: {len(te):,} ({int(is_abn.sum()):,} abnormal, {int((~is_abn).sum()):,} normal)\")\n",
    "print(pd.DataFrame(res).round(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5860b56f",
   "metadata": {},
   "source": [
    "怎麼讀這張表：\n",
    "\n",
    "- **AUC** 衡量「異常心搏的分數是否普遍高於正常心搏」，0.5 是亂猜。\n",
    "- 在「目標特異度 95%」的閾值下，**整體敏感度很低**；拆開看，V 類（心室早期收縮，形狀明顯不同）抓到的比例最高，S 類（形狀和正常很像，臨床上主要靠來得太早）幾乎抓不到——和第 14 章的觀察一致：只看單一心搏的形狀，S 類很難。\n",
    "- 自編碼器和 PCA 的數字很接近。這裡只有一次切分、15 位測試受試者，**兩者的差距未必有意義**；非線性模型不一定贏過線性基準。\n",
    "\n",
    "### 6.1 誤判集中在誰身上？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d96d210f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:48.787792Z",
     "iopub.status.busy": "2026-10-06T23:30:48.787717Z",
     "iopub.status.idle": "2026-10-06T23:30:48.794720Z",
     "shell.execute_reply": "2026-10-06T23:30:48.794340Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         normal beats  false-positive rate\n",
      "subject                                   \n",
      "117              1533                0.998\n",
      "111              2123                0.025\n",
      "212              2747                0.005\n",
      "210              2421                0.003\n",
      "232               398                0.003\n",
      "false positives from subject 117: 1,530 of 1,619; specificity without this subject: 0.997\n",
      "PCA: false positives from subject 117: 1,531 of 1,709\n"
     ]
    }
   ],
   "source": [
    "err_main = err_te_ae if keras is not None else err_te_pca\n",
    "thr_main = res[\"autoencoder (8-d)\" if keras is not None else \"PCA (8 components)\"][\"threshold\"]\n",
    "g_te = groups[te]\n",
    "fp = pd.DataFrame({\"subject\": g_te[~is_abn], \"flagged\": err_main[~is_abn] > thr_main})\n",
    "per_subject = fp.groupby(\"subject\")[\"flagged\"].agg([\"size\", \"mean\"]).rename(\n",
    "    columns={\"size\": \"normal beats\", \"mean\": \"false-positive rate\"}).sort_values(\"false-positive rate\", ascending=False)\n",
    "assert per_subject[\"normal beats\"].sum() == int((~is_abn).sum())\n",
    "print(per_subject.round(3).head(5))\n",
    "top = per_subject.index[0]\n",
    "others = fp[\"subject\"] != top\n",
    "print(f\"false positives from subject {top}: {int(fp['flagged'][~others].sum()):,} of {int(fp['flagged'].sum()):,}; \"\n",
    "      f\"specificity without this subject: {1 - fp['flagged'][others].mean():.3f}\")\n",
    "fp_pca = err_te_pca[~is_abn] > res[\"PCA (8 components)\"][\"threshold\"]\n",
    "pca_top_n = int(fp_pca[g_te[~is_abn] == top].sum())\n",
    "print(f\"PCA: false positives from subject {top}: {pca_top_n:,} of {int(fp_pca.sum()):,}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25465763",
   "metadata": {},
   "source": [
    "大部分誤判（偽陽性）來自**同一位受試者**：他的正常心搏幾乎全部被判為異常，其他人的正常心搏則很少被誤判；PCA 也一樣把這個人整段判為異常，所以問題不在非線性模型，而在這個人的心搏和訓練組的人不像。（第 9 節會看到：換一個測試折，偽陽性的數量與集中程度都不一樣。）模型學到的「正常」，其實是「訓練組那些人的正常」；遇到一位心搏形狀和訓練組差很多的人，就整段報警。這在臨床上很實際：同一份 Holter 被整段標成異常，比零星誤報更容易讓人對系統失去信任。\n",
    "\n",
    "### 6.2 換閾值：敏感度與特異度的交換"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c2ffbfb0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:48.795778Z",
     "iopub.status.busy": "2026-10-06T23:30:48.795711Z",
     "iopub.status.idle": "2026-10-06T23:30:48.811285Z",
     "shell.execute_reply": "2026-10-06T23:30:48.810976Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " validation percentile  threshold  sensitivity  specificity  sens_V\n",
      "                  0.80      0.099        0.604        0.779   0.874\n",
      "                  0.90      0.198        0.350        0.935   0.636\n",
      "                  0.95      0.246        0.249        0.945   0.458\n",
      "                  0.99      0.495        0.028        0.959   0.048\n"
     ]
    }
   ],
   "source": [
    "rows = []\n",
    "for q in [0.80, 0.90, 0.95, 0.99]:\n",
    "    r = evaluate(err_val_ae if keras is not None else err_val_pca, err_main, q)\n",
    "    rows.append({\"validation percentile\": q, \"threshold\": r[\"threshold\"],\n",
    "                 \"sensitivity\": r[\"sensitivity\"], \"specificity\": r[\"specificity\"], \"sens_V\": r[\"sens_V\"]})\n",
    "tradeoff = pd.DataFrame(rows)\n",
    "print(tradeoff.round(3).to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09aaf32b",
   "metadata": {},
   "source": [
    "閾值往下調，抓到的異常變多，但被誤判的正常心搏也變多。閾值該放哪裡，取決於臨床用途：篩檢想少漏掉（敏感度優先），還是不想讓護理站一直響（特異度優先）。\n",
    "\n",
    "下圖是測試組重建誤差的分布（橫軸取 log10，因為誤差跨好幾個數量級），虛線是閾值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1eca20bc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:48.812500Z",
     "iopub.status.busy": "2026-10-06T23:30:48.812434Z",
     "iopub.status.idle": "2026-10-06T23:30:48.890523Z",
     "shell.execute_reply": "2026-10-06T23:30:48.890110Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x350 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = np.linspace(-3, 1, 81)        # log10(error) from 0.001 to 10\n",
    "fig, ax = plt.subplots(figsize=(9, 3.5))\n",
    "ax.hist(np.log10(err_main[~is_abn]), bins=bins, density=True, alpha=0.6, color=\"#607D8B\", label=\"N (normal)\")\n",
    "ax.hist(np.log10(err_main[is_abn]), bins=bins, density=True, alpha=0.6, color=\"#F4511E\", label=\"S / V / F (abnormal)\")\n",
    "ax.axvline(np.log10(thr_main), color=\"black\", ls=\"--\", label=\"threshold (95th pct of validation N)\")\n",
    "ax.set_xlabel(\"log10(reconstruction error)\")\n",
    "ax.set_ylabel(\"density\")\n",
    "ax.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f50365d",
   "metadata": {},
   "source": [
    "## 7. 潛在空間：8 個數字裡裝了什麼？\n",
    "\n",
    "編碼器把每個心搏壓成 8 個數字，這 8 維就是潛在空間（latent space）。8 維畫不出來，所以再用 PCA 投影到 2 維（只用訓練組的潛在向量來決定投影方向）。每一點是一個測試組心搏。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f7c2b6db",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:48.891820Z",
     "iopub.status.busy": "2026-10-06T23:30:48.891733Z",
     "iopub.status.idle": "2026-10-06T23:30:49.073353Z",
     "shell.execute_reply": "2026-10-06T23:30:49.073018Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if keras is not None:\n",
    "    z_fit = encoder.predict(X2[fit_n], batch_size=4096, verbose=0)\n",
    "    z_te = encoder.predict(X2[te], batch_size=4096, verbose=0)\n",
    "    proj = PCA(n_components=2, random_state=RS).fit(z_fit)\n",
    "    z2 = proj.transform(z_te)\n",
    "    fig, ax = plt.subplots(figsize=(6, 5))\n",
    "    colors = [\"#607D8B\", \"#1f77b4\", \"#F4511E\", \"#9467bd\"]\n",
    "    for k in range(4):\n",
    "        idx = np.where(y[te] == k)[0]\n",
    "        idx = idx[:: max(1, len(idx) // 1500)]          # at most ~1,500 points per class\n",
    "        ax.scatter(z2[idx, 0], z2[idx, 1], s=4, alpha=0.5, color=colors[k], label=f\"{CLASSES[k]} (n={int((y[te] == k).sum()):,})\")\n",
    "    ax.set_xlabel(\"latent PC 1\")\n",
    "    ax.set_ylabel(\"latent PC 2\")\n",
    "    ax.legend(markerscale=4)\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff33393",
   "metadata": {},
   "source": [
    "V 類有一大片落在正常心搏聚集區之外；S 類大多和 N 疊在一起。模型從沒看過任何異常心搏、也沒有看過任何標籤，潛在空間裡的這些結構完全是「學還原正常心搏」順便學到的。\n",
    "\n",
    "## 8. 對照：如果隨機切心搏呢？\n",
    "\n",
    "把同一個自編碼器改用第 14 章的「切法 A」：所有心搏打散後隨機切，訓練與驗證的正常心搏數量和上面相同。**同一個人的正常心搏同時出現在訓練與測試。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d4588f89",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:49.074823Z",
     "iopub.status.busy": "2026-10-06T23:30:49.074616Z",
     "iopub.status.idle": "2026-10-06T23:30:53.093242Z",
     "shell.execute_reply": "2026-10-06T23:30:53.092787Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             by subject (main)  random beats (leaky)\n",
      "auc                      0.783                 0.955\n",
      "sensitivity              0.249                 0.854\n",
      "specificity              0.945                 0.950\n",
      "test-set class counts N/S/V/F  by subject: [29498, 1463, 2072, 388] | random beats: [30030, 927, 2336, 267]\n"
     ]
    }
   ],
   "source": [
    "if keras is not None:\n",
    "    r_tr, r_te = next(StratifiedKFold(3, shuffle=True, random_state=RS).split(X, y))\n",
    "    r_n = np.random.default_rng(RS).permutation(r_tr[y[r_tr] == 0])\n",
    "    r_fit, r_val = r_n[:len(fit_n)], r_n[len(fit_n):len(fit_n) + len(val_n)]\n",
    "    assert len(set(groups[r_te]) - set(groups[r_fit])) == 0      # every test subject was seen in training\n",
    "    _, ae_r, _, _ = train_autoencoder(r_fit, r_val)\n",
    "    err_r = ae_error(ae_r, r_te)\n",
    "    thr_r = np.quantile(ae_error(ae_r, r_val), 0.95)\n",
    "    abn_r = y[r_te] != 0\n",
    "    res_random = {\"auc\": roc_auc_score(abn_r, err_r), \"sensitivity\": (err_r[abn_r] > thr_r).mean(),\n",
    "                  \"specificity\": (err_r[~abn_r] <= thr_r).mean()}\n",
    "    cmp = pd.DataFrame({\"by subject (main)\": {k: res[\"autoencoder (8-d)\"][k] for k in res_random},\n",
    "                        \"random beats (leaky)\": res_random})\n",
    "    print(cmp.round(3))\n",
    "    comp_main, comp_random = np.bincount(y[te], minlength=4).tolist(), np.bincount(y[r_te], minlength=4).tolist()\n",
    "    print(\"test-set class counts N/S/V/F  by subject:\", comp_main, \"| random beats:\", comp_random)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d228fd55",
   "metadata": {},
   "source": [
    "隨機切心搏時，AUC 與敏感度都高出一大截。主因和第 14 章相同：測試組的每個人在訓練時都出現過，模型早就記住「這個人的正常長什麼樣」，所以這個人的異常心搏特別顯眼。**這個高分不代表模型對新病人有用**。要注意兩組測試心搏的類別組成不同（隨機切的 V 較多、S 較少，而 V 本來就比較好抓），所以差距有一部分來自組成；這個對照也只跑了一個種子。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9a9903e",
   "metadata": {},
   "source": [
    "## 9. 延伸實驗（建議開 GPU，可跳過）：結果有多穩定？\n",
    "\n",
    "這一節要再訓練 11 個模型；跳過的話，第 10 節仍可執行，只是不會輸出延伸實驗的數字。\n",
    "\n",
    "上面所有數字都來自**一次切分（第 1 折）、一個隨機種子（42）、一個潛在維度（8）**。這一節把這三件事各換一換。\n",
    "\n",
    "### 9.1 換潛在維度（第 1 折、種子 42）\n",
    "同時列出驗證組 AUC（選模的依據，需要驗證組受試者的異常標籤）與測試組 AUC。PCA 也用同樣的維度做一次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "31bbd315",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:30:53.094469Z",
     "iopub.status.busy": "2026-10-06T23:30:53.094393Z",
     "iopub.status.idle": "2026-10-06T23:31:05.074410Z",
     "shell.execute_reply": "2026-10-06T23:31:05.073983Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " latent  AE val AUC  AE test AUC  PCA val AUC  PCA test AUC\n",
      "      2       0.692        0.847        0.702         0.830\n",
      "      4       0.744        0.859        0.800         0.710\n",
      "      8       0.792        0.783        0.720         0.775\n",
      "     16       0.754        0.813        0.746         0.761\n",
      "chosen by AE validation AUC: 8 | highest AE test AUC: 4\n"
     ]
    }
   ],
   "source": [
    "def val_test_auc(err_fn):\n",
    "    \"\"\"AUC on all validation-subject beats and on all test beats.\"\"\"\n",
    "    return roc_auc_score(y[val] != 0, err_fn(val)), roc_auc_score(is_abn, err_fn(te))\n",
    "\n",
    "\n",
    "def pca_err_fn(p):\n",
    "    return lambda idx: np.mean((p.inverse_transform(p.transform(X2[idx])) - X2[idx]) ** 2, axis=1)\n",
    "\n",
    "\n",
    "sweep = []\n",
    "if keras is not None:\n",
    "    for lat in [2, 4, 8, 16]:\n",
    "        ae_l = ae if lat == LATENT else train_autoencoder(fit_n, val_n, latent=lat)[1]   # 8-d is the main model\n",
    "        a_val, a_te = val_test_auc(lambda idx: ae_error(ae_l, idx))\n",
    "        p_val, p_te = val_test_auc(pca_err_fn(PCA(n_components=lat, random_state=RS).fit(X2[fit_n])))\n",
    "        sweep.append({\"latent\": lat, \"AE val AUC\": a_val, \"AE test AUC\": a_te, \"PCA val AUC\": p_val, \"PCA test AUC\": p_te})\n",
    "    sweep = pd.DataFrame(sweep)\n",
    "    print(sweep.round(3).to_string(index=False))\n",
    "    print(\"chosen by AE validation AUC:\", int(sweep.loc[sweep[\"AE val AUC\"].idxmax(), \"latent\"]),\n",
    "          \"| highest AE test AUC:\", int(sweep.loc[sweep[\"AE test AUC\"].idxmax(), \"latent\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "006f4921",
   "metadata": {},
   "source": [
    "主結果用的 8 維是驗證組 AUC 最高的；但在測試組上，8 維**不是**最好的。這正是不能拿測試組挑模型的原因：看著測試組挑，就會挑到測試組上運氣最好的那個，報出來的成績偏樂觀。\n",
    "\n",
    "### 9.2 換隨機種子、換測試折（8 維）\n",
    "三個測試折 × 三個種子，共 9 個模型（第 1 折種子 42 就是主結果）。每一折都照主結果的方式切訓練／驗證組，以驗證組正常心搏的第 95 百分位數當閾值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "89bd5642",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:31:05.075582Z",
     "iopub.status.busy": "2026-10-06T23:31:05.075512Z",
     "iopub.status.idle": "2026-10-06T23:31:37.275280Z",
     "shell.execute_reply": "2026-10-06T23:31:37.274730Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " fold  seed   AUC  PCA AUC  sens  spec  sens_S  sens_V   FP top FP subject  top FP share\n",
      "    1    42 0.783    0.775 0.249 0.945   0.011   0.458 1619            117         0.945\n",
      "    1     1 0.760    0.775 0.344 0.939   0.018   0.629 1812            117         0.845\n",
      "    1     2 0.859    0.775 0.427 0.940   0.137   0.699 1782            117         0.860\n",
      "    2    42 0.840    0.823 0.338 0.992   0.291   0.360  266            231         0.541\n",
      "    2     1 0.840    0.823 0.390 0.970   0.321   0.421 1011            231         0.823\n",
      "    2     2 0.846    0.823 0.385 0.983   0.313   0.416  565            231         0.781\n",
      "    3    42 0.828    0.792 0.120 0.987   0.030   0.151  346            207         0.277\n",
      "    3     1 0.835    0.792 0.217 0.985   0.037   0.278  409            222         0.323\n",
      "    3     2 0.836    0.792 0.207 0.980   0.056   0.261  543            222         0.262\n",
      "\n",
      "range over all 9 models [min, max]:\n",
      "  AUC: [0.760, 0.859]\n",
      "  sens: [0.120, 0.427]\n",
      "  spec: [0.939, 0.992]\n",
      "  sens_S: [0.011, 0.321]\n",
      "  sens_V: [0.151, 0.699]\n",
      "fold 1 only (3 seeds): AUC [0.760, 0.859] | sens [0.249, 0.427] | sens_V [0.458, 0.699]\n",
      "AE AUC minus PCA AUC per fold (seed 42): [0.008, 0.017, 0.036]\n"
     ]
    }
   ],
   "source": [
    "SEEDS = [42, 1, 2]\n",
    "folds = list(StratifiedGroupKFold(3, shuffle=True, random_state=RS).split(X, y, groups))\n",
    "robust = []\n",
    "if keras is not None:\n",
    "    for k, (tr_k, te_k) in enumerate(folds):\n",
    "        fi, vi = next(GroupShuffleSplit(n_splits=1, test_size=0.25, random_state=RS).split(tr_k, groups=groups[tr_k]))\n",
    "        fit_k, val_k = tr_k[fi], tr_k[vi]\n",
    "        assert not (set(groups[fit_k]) & set(groups[te_k])) and not (set(groups[val_k]) & set(groups[te_k]))\n",
    "        assert not (set(groups[fit_k]) & set(groups[val_k]))\n",
    "        fitn_k, valn_k, abn_k = fit_k[y[fit_k] == 0], val_k[y[val_k] == 0], y[te_k] != 0\n",
    "        pca_auc = roc_auc_score(abn_k, pca_err_fn(PCA(n_components=LATENT, random_state=RS).fit(X2[fitn_k]))(te_k))\n",
    "        for seed in SEEDS:\n",
    "            ae_k = ae if (k == 0 and seed == RS) else train_autoencoder(fitn_k, valn_k, seed=seed)[1]\n",
    "            e_te, thr_k = ae_error(ae_k, te_k), np.quantile(ae_error(ae_k, valn_k), 0.95)\n",
    "            flag = e_te > thr_k\n",
    "            fp_subj = pd.Series(groups[te_k][~abn_k][flag[~abn_k]]).value_counts()\n",
    "            robust.append({\"fold\": k + 1, \"seed\": seed, \"AUC\": roc_auc_score(abn_k, e_te), \"PCA AUC\": pca_auc,\n",
    "                           \"sens\": flag[abn_k].mean(), \"spec\": (~flag[~abn_k]).mean(),\n",
    "                           \"sens_S\": flag[y[te_k] == 1].mean(), \"sens_V\": flag[y[te_k] == 2].mean(),\n",
    "                           \"FP\": int(flag[~abn_k].sum()), \"top FP subject\": str(fp_subj.index[0]),\n",
    "                           \"top FP share\": fp_subj.iloc[0] / fp_subj.sum()})\n",
    "    robust = pd.DataFrame(robust)\n",
    "    assert len(robust) == 3 * len(SEEDS)\n",
    "    print(robust.round(3).to_string(index=False))\n",
    "    print(\"\\nrange over all 9 models [min, max]:\")\n",
    "    for c in [\"AUC\", \"sens\", \"spec\", \"sens_S\", \"sens_V\"]:\n",
    "        print(f\"  {c}: [{robust[c].min():.3f}, {robust[c].max():.3f}]\")\n",
    "    f1 = robust[robust[\"fold\"] == 1]\n",
    "    print(\"fold 1 only (3 seeds): \" + \" | \".join(f\"{c} [{f1[c].min():.3f}, {f1[c].max():.3f}]\" for c in [\"AUC\", \"sens\", \"sens_V\"]))\n",
    "    print(\"AE AUC minus PCA AUC per fold (seed 42):\",\n",
    "          [round(float(r[\"AUC\"] - r[\"PCA AUC\"]), 3) for _, r in robust[robust[\"seed\"] == RS].iterrows()])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45eec0da",
   "metadata": {},
   "source": [
    "怎麼讀：\n",
    "\n",
    "- 只換隨機種子，敏感度與 V 類敏感度就會跳動；所以「抓到幾成」要看範圍，不要只看一個數字。\n",
    "- `top FP share` 是偽陽性中來自「誤判最多的那位受試者」的比例。第 1 折（受試者 117）誤判多且集中；第 2 折也有一半以上來自單一受試者，但誤判總數少得多；第 3 折較分散。\n",
    "- 每一折自編碼器與 PCA 的 AUC 差距都要和種子造成的跳動一起看。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dacec37",
   "metadata": {},
   "source": [
    "## 10. 整理結果\n",
    "\n",
    "下一格把關鍵數字整理成一行機器可讀的 JSON（網站的圖與互動 demo 由 `scripts/figs_ch16.py` 讀這一行並核對）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1252b529",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:31:37.276445Z",
     "iopub.status.busy": "2026-10-06T23:31:37.276360Z",
     "iopub.status.idle": "2026-10-06T23:31:37.282121Z",
     "shell.execute_reply": "2026-10-06T23:31:37.281747Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS_JSON {\"subjects\": {\"train\": 21, \"val\": 7, \"test\": 15}, \"beats\": {\"train_n\": 45184, \"val_n\": 15407, \"test\": 33421, \"test_abnormal\": 3923}, \"params\": 19901, \"ae\": {\"threshold\": 0.246, \"auc\": 0.7827, \"sensitivity\": 0.249, \"specificity\": 0.9451, \"sens_S\": 0.0109, \"sens_V\": 0.458, \"sens_F\": 0.0309}, \"pca\": {\"threshold\": 0.1896, \"auc\": 0.7748, \"sensitivity\": 0.2228, \"specificity\": 0.9421, \"sens_S\": 0.0191, \"sens_V\": 0.4011, \"sens_F\": 0.0387}, \"pca_var\": 0.9149, \"random\": {\"auc\": 0.9552, \"sensitivity\": 0.8541, \"specificity\": 0.9501}, \"tradeoff\": [{\"validation percentile\": 0.8, \"threshold\": 0.0992, \"sensitivity\": 0.6044, \"specificity\": 0.7788, \"sens_V\": 0.874}, {\"validation percentile\": 0.9, \"threshold\": 0.1977, \"sensitivity\": 0.35, \"specificity\": 0.9345, \"sens_V\": 0.6361}, {\"validation percentile\": 0.95, \"threshold\": 0.246, \"sensitivity\": 0.249, \"specificity\": 0.9451, \"sens_V\": 0.458}, {\"validation percentile\": 0.99, \"threshold\": 0.4947, \"sensitivity\": 0.0275, \"specificity\": 0.9591, \"sens_V\": 0.0478}], \"fp_top_subject\": \"117\", \"spec_without_top\": 0.9968, \"fp_total\": 1619, \"fp_top_n\": 1530, \"pca_fp_total\": 1709, \"pca_fp_top_n\": 1531, \"train_mse\": 0.0172, \"val_mse\": 0.08, \"comp_main\": [29498, 1463, 2072, 388], \"comp_random\": [30030, 927, 2336, 267], \"hist_bins\": [-3.0, -2.95, -2.9, -2.85, -2.8, -2.75, -2.7, -2.65, -2.6, -2.55, -2.5, -2.45, -2.4, -2.35, -2.3, -2.25, -2.2, -2.15, -2.1, -2.05, -2.0, -1.95, -1.9, -1.85, -1.8, -1.75, -1.7, -1.65, -1.6, -1.55, -1.5, -1.45, -1.4, -1.35, -1.3, -1.25, -1.2, -1.15, -1.1, -1.05, -1.0, -0.95, -0.9, -0.85, -0.8, -0.75, -0.7, -0.65, -0.6, -0.55, -0.5, -0.45, -0.4, -0.35, -0.3, -0.25, -0.2, -0.15, -0.1, -0.05, 0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0], \"hist_counts\": {\"N\": [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 18, 27, 60, 111, 180, 278, 361, 458, 575, 676, 703, 786, 848, 938, 920, 932, 1096, 1351, 1588, 1452, 1140, 1130, 1426, 1810, 1736, 1436, 977, 622, 542, 736, 1006, 1009, 659, 216, 73, 35, 25, 27, 45, 77, 234, 396, 369, 258, 114, 27, 5, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \"S\": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 8, 1, 2, 4, 12, 22, 27, 81, 128, 190, 212, 223, 178, 126, 104, 52, 32, 23, 6, 8, 3, 1, 3, 0, 1, 0, 2, 1, 0, 2, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \"V\": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 4, 3, 1, 7, 12, 6, 10, 14, 14, 20, 23, 28, 23, 32, 38, 23, 39, 52, 63, 95, 120, 142, 140, 260, 287, 200, 132, 82, 63, 41, 46, 19, 15, 4, 0, 2, 4, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \"F\": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 3, 2, 4, 7, 1, 4, 8, 2, 7, 2, 4, 4, 9, 8, 7, 7, 9, 10, 9, 12, 13, 9, 31, 31, 38, 34, 19, 25, 22, 14, 10, 8, 3, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}, \"sweep\": [{\"latent\": 2, \"AE val AUC\": 0.6918, \"AE test AUC\": 0.8474, \"PCA val AUC\": 0.7017, \"PCA test AUC\": 0.83}, {\"latent\": 4, \"AE val AUC\": 0.744, \"AE test AUC\": 0.8593, \"PCA val AUC\": 0.8001, \"PCA test AUC\": 0.7095}, {\"latent\": 8, \"AE val AUC\": 0.7923, \"AE test AUC\": 0.7827, \"PCA val AUC\": 0.7205, \"PCA test AUC\": 0.7748}, {\"latent\": 16, \"AE val AUC\": 0.7543, \"AE test AUC\": 0.8125, \"PCA val AUC\": 0.7457, \"PCA test AUC\": 0.7615}], \"robust\": [{\"fold\": 1, \"seed\": 42, \"AUC\": 0.7827, \"PCA AUC\": 0.7748, \"sens\": 0.249, \"spec\": 0.9451, \"sens_S\": 0.0109, \"sens_V\": 0.458, \"FP\": 1619, \"top FP subject\": \"117\", \"top FP share\": 0.945}, {\"fold\": 1, \"seed\": 1, \"AUC\": 0.7603, \"PCA AUC\": 0.7748, \"sens\": 0.3439, \"spec\": 0.9386, \"sens_S\": 0.0185, \"sens_V\": 0.6293, \"FP\": 1812, \"top FP subject\": \"117\", \"top FP share\": 0.8449}, {\"fold\": 1, \"seed\": 2, \"AUC\": 0.8594, \"PCA AUC\": 0.7748, \"sens\": 0.4272, \"spec\": 0.9396, \"sens_S\": 0.1374, \"sens_V\": 0.6993, \"FP\": 1782, \"top FP subject\": \"117\", \"top FP share\": 0.8597}, {\"fold\": 2, \"seed\": 42, \"AUC\": 0.8402, \"PCA AUC\": 0.8234, \"sens\": 0.338, \"spec\": 0.992, \"sens_S\": 0.2907, \"sens_V\": 0.3596, \"FP\": 266, \"top FP subject\": \"231\", \"top FP share\": 0.5414}, {\"fold\": 2, \"seed\": 1, \"AUC\": 0.8403, \"PCA AUC\": 0.8234, \"sens\": 0.3905, \"spec\": 0.9695, \"sens_S\": 0.3212, \"sens_V\": 0.421, \"FP\": 1011, \"top FP subject\": \"231\", \"top FP share\": 0.8229}, {\"fold\": 2, \"seed\": 2, \"AUC\": 0.8461, \"PCA AUC\": 0.8234, \"sens\": 0.3847, \"spec\": 0.983, \"sens_S\": 0.313, \"sens_V\": 0.4161, \"FP\": 565, \"top FP subject\": \"231\", \"top FP share\": 0.7805}, {\"fold\": 3, \"seed\": 42, \"AUC\": 0.8279, \"PCA AUC\": 0.7919, \"sens\": 0.1197, \"spec\": 0.9874, \"sens_S\": 0.0301, \"sens_V\": 0.1514, \"FP\": 346, \"top FP subject\": \"207\", \"top FP share\": 0.2775}, {\"fold\": 3, \"seed\": 1, \"AUC\": 0.8353, \"PCA AUC\": 0.7919, \"sens\": 0.2175, \"spec\": 0.9851, \"sens_S\": 0.0366, \"sens_V\": 0.2782, \"FP\": 409, \"top FP subject\": \"222\", \"top FP share\": 0.3227}, {\"fold\": 3, \"seed\": 2, \"AUC\": 0.8362, \"PCA AUC\": 0.7919, \"sens\": 0.207, \"spec\": 0.9802, \"sens_S\": 0.0559, \"sens_V\": 0.2607, \"FP\": 543, \"top FP subject\": \"222\", \"top FP share\": 0.2615}]}\n"
     ]
    }
   ],
   "source": [
    "if keras is not None:\n",
    "    hist_counts = {c: np.histogram(np.log10(err_main[y[te] == k]), bins=bins)[0].tolist() for k, c in enumerate(CLASSES)}\n",
    "    assert sum(sum(v) for v in hist_counts.values()) == len(te)   # every test beat falls inside the bins\n",
    "    summary = {\n",
    "        \"subjects\": {\"train\": len(S_fit), \"val\": len(S_val), \"test\": len(S_te)},\n",
    "        \"beats\": {\"train_n\": len(fit_n), \"val_n\": len(val_n), \"test\": len(te), \"test_abnormal\": int(is_abn.sum())},\n",
    "        \"params\": ae.count_params(),\n",
    "        \"ae\": {k: round(float(v), 4) for k, v in res[\"autoencoder (8-d)\"].items()},\n",
    "        \"pca\": {k: round(float(v), 4) for k, v in res[\"PCA (8 components)\"].items()},\n",
    "        \"pca_var\": round(float(pca.explained_variance_ratio_.sum()), 4),\n",
    "        \"random\": {k: round(float(v), 4) for k, v in res_random.items()},\n",
    "        \"tradeoff\": tradeoff.round(4).to_dict(orient=\"records\"),\n",
    "        \"fp_top_subject\": str(top), \"spec_without_top\": round(float(1 - fp[\"flagged\"][others].mean()), 4),\n",
    "        \"fp_total\": int(fp[\"flagged\"].sum()), \"fp_top_n\": int(fp[\"flagged\"][~others].sum()),\n",
    "        \"pca_fp_total\": int(fp_pca.sum()), \"pca_fp_top_n\": pca_top_n,\n",
    "        \"train_mse\": round(float(hist.history[\"loss\"][-1]), 4), \"val_mse\": round(float(hist.history[\"val_loss\"][-1]), 4),\n",
    "        \"comp_main\": comp_main, \"comp_random\": comp_random,\n",
    "\n",
    "        \"hist_bins\": bins.round(3).tolist(), \"hist_counts\": hist_counts,\n",
    "    }\n",
    "    if \"sweep\" in globals() and \"robust\" in globals():          # section 9 was run\n",
    "        summary[\"sweep\"] = sweep.round(4).to_dict(orient=\"records\")\n",
    "        summary[\"robust\"] = robust.round(4).to_dict(orient=\"records\")\n",
    "    else:\n",
    "        print(\"Section 9 (extra experiments) was skipped: its numbers are not included below.\")\n",
    "    print(\"RESULTS_JSON\", json.dumps(summary))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "70110164",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-06T23:31:37.283097Z",
     "iopub.status.busy": "2026-10-06T23:31:37.283038Z",
     "iopub.status.idle": "2026-10-06T23:31:37.285072Z",
     "shell.execute_reply": "2026-10-06T23:31:37.284593Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total notebook time: 55.9 s (download + reading 0.7 s)\n"
     ]
    }
   ],
   "source": [
    "print(f\"total notebook time: {time.time() - T_START:.1f} s (download + reading {T_LOAD:.1f} s)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf3bc97a",
   "metadata": {},
   "source": [
    "## 11. 動手試試\n",
    "\n",
    "1. **改潛在維度**：把 `LATENT` 改成 2 或 16，重跑第 4 節之後的所有格子。瓶頸越窄，正常心搏的還原越差；AUC 會怎麼變？\n",
    "2. **換閾值**：在 `evaluate` 裡把 `q` 改成 0.90 或 0.99，對照第 6.2 節的表格，找出你覺得「適合 Holter 篩檢」的點，並說明理由。\n",
    "3. **只用「真正正常」的心搏訓練**：AAMI 的 N 類包含左右束支傳導阻滯的心搏（符號 L、R）。在第 2 節多記一個 `symbols` 清單，訓練時只用符號為 `N` 的心搏，看束支傳導阻滯的受試者在測試組會不會變成大量偽陽性。\n",
    "4. **換成一維卷積自編碼器**：把編碼器前兩層換成 `Reshape((117, 1))`、`Conv1D(16, 7, padding=\"same\", activation=\"relu\")`、`MaxPooling1D(3)`、`Flatten()`，比較 AUC。結果不一定比較好——記得只換種子成績也會跳動。\n",
    "\n",
    "## 參考資料\n",
    "\n",
    "- Moody GB, Mark RG. The impact of the MIT-BIH Arrhythmia Database. *IEEE Eng Med Biol Mag* 2001;20(3):45–50.\n",
    "- Goldberger AL, et al. PhysioBank, PhysioToolkit, and PhysioNet. *Circulation* 2000;101(23):e215–e220.\n",
    "- Hinton GE, Salakhutdinov RR. Reducing the dimensionality of data with neural networks. *Science* 2006;313(5786):504–507.\n",
    "- MIT-BIH Arrhythmia Database v1.0.0：<https://physionet.org/content/mitdb/1.0.0/>（ODC-By v1.0）"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}