{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch11-000",
   "metadata": {},
   "source": [
    "# 11장 실습. PyTorch 학습 루프\n",
    "\n",
    "**목표:** 표 데이터(유방암 진단, 특성 30개)로 `Dataset`·`DataLoader`를 만들고, 한 에폭 학습·평가 함수, 검증 손실로 가장 좋은 에폭을 남기는 학습 함수, 체크포인트 저장·재로딩을 직접 쓴다. 학습 곡선을 보고 원인을 진단한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 배열을 바꾸지 않는다.** 모델·옵티마이저를 받는 함수는 그 객체를 학습시키는 것이 목적이므로 바꿔도 된다.\n",
    "- 문제 3은 문제 2를, 문제 6은 문제 4·5를, 문제 7은 문제 4를 쓴다. 순서대로 푼다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 데이터는 sklearn에 들어 있어 내려받기가 없고, CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import copy, hashlib, math, os, tempfile\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "plt.rcParams[\"font.family\"] = \"Malgun Gothic\"     # Windows 한글 글꼴\n",
    "plt.rcParams[\"axes.unicode_minus\"] = False\n",
    "\n",
    "def check(name, value, digest):\n",
    "    assert value is not None, f\"{name}: 답을 적으세요\"\n",
    "    got = hashlib.sha256(str(value).strip().upper().encode()).hexdigest()[:12]\n",
    "    assert got == digest, f\"{name}: 다시 생각해 보세요\"\n",
    "    print(name, \"통과\")\n",
    "\n",
    "# 유방암 진단: 종양 측정값 30개 → 양성(1)/악성(0). 단위가 제각각이라 표준화한다(훈련 데이터로만 맞춤)\n",
    "Xb, yb = load_breast_cancer(return_X_y=True)\n",
    "X_tr, X_va, y_tr, y_va = train_test_split(Xb, yb, test_size=0.25, stratify=yb, random_state=0)\n",
    "scaler = StandardScaler().fit(X_tr)\n",
    "X_tr_s, X_va_s = scaler.transform(X_tr), scaler.transform(X_va)\n",
    "print(\"훈련\", X_tr_s.shape, \"검증\", X_va_s.shape, \"/ 1의 비율\", round(yb.mean(), 3))\n",
    "\n",
    "def make_model(seed=0, d=30, h=16):\n",
    "    torch.manual_seed(seed)\n",
    "    return nn.Sequential(nn.Linear(d, h), nn.ReLU(), nn.Linear(h, h), nn.ReLU(), nn.Linear(h, 1))\n",
    "\n",
    "loss_fn = nn.BCEWithLogitsLoss()                   # 모델 출력은 시그모이드 전 점수(로짓)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-002",
   "metadata": {},
   "source": [
    "## 문제 1. 배치·에폭·스텝, DataLoader 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q1`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) 훈련 데이터 426개를 `batch_size=32`(`drop_last=False`)로 나누면 에폭당 스텝은 14번이다.\n",
    "(b) 데이터 수가 같을 때 배치 크기를 키우면 에폭당 스텝 수가 늘어난다.\n",
    "(c) `shuffle=True`인 `DataLoader`는 처음 한 번 섞은 순서를 모든 에폭에서 그대로 쓴다.\n",
    "(d) 미니배치 기울기 하나는 전체 데이터 기울기와 꽤 다를 수 있지만, 무작위 배치 여러 개의 기울기를 평균하면 전체 기울기에 가깝다.\n",
    "(e) 검증용 `DataLoader`도 `shuffle=True`로 해야 평가 손실이 공정하게 나온다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q1 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"7972a442af7a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-005",
   "metadata": {},
   "source": [
    "## 문제 2. 표 데이터 `Dataset` (코드)\n",
    "\n",
    "`TabularDataset(X, y)` 클래스를 완성하세요. NumPy 특성 `X`(N, d)와 정답 `y`(N,)를 받습니다.\n",
    "\n",
    "- `__init__`: `X`를 float32 텐서 `(N, d)`, `y`를 float32 텐서 `(N, 1)`로 **복사해** `self.X`·`self.y`에 둡니다(원본 배열을 나중에 바꿔도 영향이 없어야 합니다).\n",
    "- `__len__`: 표본 수.\n",
    "- `__getitem__(i)`: `(특성 (d,), 정답 (1,))` 튜플.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 11-4절 `ArrayDataset`과 같습니다. `torch.tensor(X, dtype=torch.float32)`는 늘 복사합니다. `torch.from_numpy`는 메모리를 공유하므로 쓰지 않습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "class TabularDataset(Dataset):\n",
    "    def __init__(self, X, y):\n",
    "        pass   # 작성\n",
    "\n",
    "    def __len__(self):\n",
    "        pass   # 작성\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "Xa, ya = X_tr_s[:7].copy(), y_tr[:7].copy()\n",
    "X0, y0 = Xa.copy(), ya.copy()\n",
    "ds2 = TabularDataset(Xa, ya)\n",
    "assert np.array_equal(Xa, X0) and np.array_equal(ya, y0), \"입력 배열이 바뀌었습니다\"\n",
    "assert len(ds2) == 7, f\"len이 {len(ds2)}입니다. 표본 수 7이어야 합니다\"\n",
    "item = ds2[3]\n",
    "assert isinstance(item, tuple) and len(item) == 2, \"(특성, 정답) 튜플 두 개를 돌려주세요\"\n",
    "x3, y3 = item\n",
    "assert isinstance(x3, torch.Tensor) and isinstance(y3, torch.Tensor), \"둘 다 torch.Tensor여야 합니다\"\n",
    "assert x3.dtype == torch.float32 and y3.dtype == torch.float32, f\"dtype이 {x3.dtype}, {y3.dtype}입니다. 둘 다 float32\"\n",
    "assert tuple(x3.shape) == (30,), f\"특성 모양이 {tuple(x3.shape)}입니다. 표본 하나는 (d,)\"\n",
    "assert tuple(y3.shape) == (1,), f\"정답 모양이 {tuple(y3.shape)}입니다. (1,)이어야 배치가 (B, 1)이 됩니다\"\n",
    "assert np.allclose(x3.numpy(), Xa[3]) and y3.item() == ya[3], \"3번 표본의 값이 원래 배열과 다릅니다\"\n",
    "assert np.allclose(ds2[-1][0].numpy(), Xa[-1]), \"음수 인덱스(-1)도 마지막 표본을 꺼내야 합니다\"\n",
    "Xf, yf = X_tr_s[:4].astype(np.float32), y_tr[:4].astype(np.float32)\n",
    "ds2f = TabularDataset(Xf, yf)\n",
    "Xf[0, 0], yf[0] = 999.0, 7.0\n",
    "assert ds2f[0][0][0].item() != 999.0 and ds2f[0][1].item() != 7.0, \"float32 원본을 바꿨더니 Dataset 값도 바뀌었습니다. 복사하세요\"\n",
    "xb2, yb2 = next(iter(DataLoader(ds2, batch_size=5)))\n",
    "assert tuple(xb2.shape) == (5, 30) and tuple(yb2.shape) == (5, 1), f\"배치 모양이 {tuple(xb2.shape)}, {tuple(yb2.shape)}입니다\"\n",
    "train_ds, val_ds = TabularDataset(X_tr_s, y_tr), TabularDataset(X_va_s, y_va)\n",
    "print(len(train_ds), len(val_ds), \"/ 배치\", tuple(xb2.shape), tuple(yb2.shape))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-008",
   "metadata": {},
   "source": [
    "## 문제 3. 훈련·검증 `DataLoader` (코드)\n",
    "\n",
    "`make_loaders(train_ds, val_ds, batch_size, seed)`를 쓰세요. `(train_loader, val_loader)`를 돌려줍니다.\n",
    "\n",
    "- 훈련: `batch_size`개씩, **에폭마다 섞고**, 같은 `seed`면 섞는 순서가 재현되게 합니다.\n",
    "- 검증: 같은 `batch_size`, **섞지 않습니다**.\n",
    "- 마지막 작은 배치는 버리지 않습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`DataLoader(train_ds, batch_size=batch_size, shuffle=True, generator=torch.Generator().manual_seed(seed))`. 검증은 `shuffle=False`(기본값).\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def make_loaders(train_ds, val_ds, batch_size, seed):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-010",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "idx_ds = TabularDataset(np.arange(50, dtype=float).reshape(-1, 1), np.zeros(50))   # 특성 = 행 번호\n",
    "def order(loader):\n",
    "    return [int(v) for xb, _ in loader for v in xb[:, 0]]\n",
    "\n",
    "idx_val = TabularDataset(np.arange(100, 130, dtype=float).reshape(-1, 1), np.ones(30))   # 검증: 100~129\n",
    "res3 = make_loaders(idx_ds, idx_val, 8, seed=0)\n",
    "assert res3 is not None, \"결과를 return 하세요\"\n",
    "tl, vl = res3\n",
    "assert isinstance(tl, DataLoader) and isinstance(vl, DataLoader), \"둘 다 DataLoader여야 합니다\"\n",
    "assert len(tl) == math.ceil(50 / 8), f\"훈련 배치 수가 {len(tl)}입니다. 50개를 8개씩이면 7(마지막 배치를 버리지 않음)\"\n",
    "assert len(vl) == math.ceil(30 / 8), f\"검증 배치 수가 {len(vl)}입니다. 검증 30개를 8개씩이면 4\"\n",
    "assert order(vl) == list(range(100, 130)), \"검증 로더는 val_ds를 섞지 않고 원래 순서대로 줍니다\"\n",
    "assert [len(xb) for xb, _ in vl] == [8, 8, 8, 6], \"검증 배치 크기도 batch_size입니다\"\n",
    "e1, e2 = order(tl), order(tl)\n",
    "assert sorted(e1) == list(range(50)), \"한 에폭에 모든 표본이 한 번씩 나와야 합니다\"\n",
    "assert e1 != list(range(50)), \"훈련 데이터를 섞으세요(shuffle=True)\"\n",
    "assert e1 != e2, \"에폭마다 순서가 달라야 합니다\"\n",
    "tl_again, _ = make_loaders(idx_ds, idx_val, 8, seed=0)\n",
    "assert order(tl_again) == e1 and order(tl_again) == e2, \"같은 seed로 다시 만들면 에폭별 섞는 순서가 재현되어야 합니다(generator)\"\n",
    "assert [len(xb) for xb, _ in tl] == [8] * 6 + [2], \"배치 크기가 batch_size가 아닙니다\"\n",
    "tl_other, _ = make_loaders(idx_ds, idx_val, 8, seed=1)\n",
    "assert order(tl_other) != e1, \"seed가 다르면 순서도 달라야 합니다. seed 인자를 쓰세요\"\n",
    "torch.manual_seed(123); a = order(make_loaders(idx_ds, idx_val, 8, seed=5)[0])\n",
    "torch.manual_seed(456); b = order(make_loaders(idx_ds, idx_val, 8, seed=5)[0])\n",
    "assert a == b, \"전역 난수(torch.manual_seed)가 달라도 같은 seed면 같은 순서여야 합니다. 전용 Generator를 넘기세요\"\n",
    "train_loader, val_loader = make_loaders(train_ds, val_ds, 32, seed=0)\n",
    "print(\"에폭당 스텝\", len(train_loader), \"/ 첫 에폭 앞 8개\", e1[:8])\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-011",
   "metadata": {},
   "source": [
    "## 문제 4. 한 에폭 학습 (코드)\n",
    "\n",
    "`train_one_epoch(model, loader, optimizer, loss_fn)`을 쓰세요. 로더를 한 바퀴 돌며 배치마다 학습하고, **이번 에폭의 평균 훈련 손실**(파이썬 `float`)을 돌려줍니다.\n",
    "\n",
    "- 시작할 때 `model.train()`.\n",
    "- 배치마다: 기울기 비우기 → 순전파·손실 → `backward()` → `step()` (원고 11-5절 네 줄).\n",
    "- 평균은 **표본 기준**입니다. 배치 손실(배치 평균)에 배치 크기를 곱해 더한 뒤 전체 표본 수로 나눕니다. 마지막 배치가 작으므로 \"배치 평균들의 평균\"과 다릅니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`total += loss.item() * len(xb)`, `n += len(xb)`, 끝에 `return total / n`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def train_one_epoch(model, loader, optimizer, loss_fn):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "def ref_epoch(model, loader, optimizer):           # 점검용 기준 구현\n",
    "    model.train(); total, n = 0.0, 0\n",
    "    for xb, yb in loader:\n",
    "        optimizer.zero_grad(); loss = loss_fn(model(xb), yb); loss.backward(); optimizer.step()\n",
    "        total += loss.item() * len(xb); n += len(xb)\n",
    "    return total / n\n",
    "\n",
    "def fresh(seed=0):\n",
    "    return DataLoader(train_ds, batch_size=32, shuffle=True, generator=torch.Generator().manual_seed(seed))\n",
    "\n",
    "m_a, m_b = make_model(), make_model()\n",
    "o_a, o_b = torch.optim.SGD(m_a.parameters(), lr=0.05), torch.optim.SGD(m_b.parameters(), lr=0.05)\n",
    "la = None\n",
    "for _ in range(2):\n",
    "    la = train_one_epoch(m_a, fresh(), o_a, loss_fn)\n",
    "    lb = ref_epoch(m_b, fresh(), o_b)\n",
    "assert la is not None, \"결과를 return 하세요\"\n",
    "assert isinstance(la, float), f\"평균 손실을 파이썬 float로 돌려주세요(지금 {type(la).__name__}). loss.item()\"\n",
    "assert all(torch.allclose(p, q) for p, q in zip(m_a.parameters(), m_b.parameters())), \"2에폭 뒤 매개변수가 기준 구현과 다릅니다. zero_grad·backward·step 순서를 확인하세요\"\n",
    "mean_of_means = None\n",
    "m_c = make_model(); o_c = torch.optim.SGD(m_c.parameters(), lr=0.0)          # 학습률 0: 매개변수 고정\n",
    "batch_losses = [(loss_fn(m_c(xb), yb).item(), len(xb)) for xb, yb in fresh()]\n",
    "got = train_one_epoch(m_c, fresh(), o_c, loss_fn)\n",
    "want = sum(l * k for l, k in batch_losses) / sum(k for _, k in batch_losses)\n",
    "mean_of_means = np.mean([l for l, _ in batch_losses])\n",
    "assert np.isclose(got, want, rtol=1e-6), f\"평균 손실 {got:.6f} ≠ 표본 기준 평균 {want:.6f}\" + (\" (배치 평균들의 평균을 냈습니다)\" if np.isclose(got, mean_of_means) else \"\")\n",
    "assert np.isclose(la, lb, rtol=1e-6), \"돌려준 평균 손실이 기준 구현과 다릅니다\"\n",
    "m_d = nn.Sequential(nn.Linear(30, 8), nn.Dropout(0.5), nn.Linear(8, 1)); m_d.eval()\n",
    "train_one_epoch(m_d, fresh(), torch.optim.SGD(m_d.parameters(), lr=0.01), loss_fn)\n",
    "assert m_d.training, \"학습 함수 시작에서 model.train()을 부르세요(평가 모드로 넘어온 모델도 훈련 모드로)\"\n",
    "print(f\"2에폭 뒤 평균 훈련 손실 {la:.4f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-014",
   "metadata": {},
   "source": [
    "## 문제 5. 평가 함수 (코드)\n",
    "\n",
    "`evaluate(model, X, y, loss_fn)`을 쓰세요. 텐서 `X`(N, d)·`y`(N, 1)를 받아 `(평균 손실, 정확도)`를 파이썬 `float` 두 개로 돌려줍니다.\n",
    "\n",
    "- `model.eval()`로 평가 모드, `torch.no_grad()`로 기록 없이 계산합니다.\n",
    "- 정확도: 점수 z > 0(확률 0.5 초과)을 1로 예측해 정답과 같은 비율.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 11-5절 `evaluate`. `((z > 0).float() == y).float().mean().item()`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def evaluate(model, X, y, loss_fn):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "Xv_t, yv_t = val_ds.X, val_ds.y\n",
    "Xt_t, yt_t = train_ds.X, train_ds.y\n",
    "m5 = make_model(seed=3)\n",
    "res5 = evaluate(m5, Xv_t, yv_t, loss_fn)\n",
    "assert res5 is not None, \"결과를 return 하세요\"\n",
    "l5, a5 = res5\n",
    "assert isinstance(l5, float) and isinstance(a5, float), f\"float 두 개를 돌려주세요(지금 {type(l5).__name__}, {type(a5).__name__})\"\n",
    "with torch.no_grad():\n",
    "    z5 = m5(Xv_t)\n",
    "assert np.isclose(l5, loss_fn(z5, yv_t).item()), \"손실이 기준과 다릅니다\"\n",
    "assert np.isclose(a5, ((z5 > 0).float() == yv_t).float().mean().item()), \"정확도가 기준과 다릅니다. z > 0을 1로 예측합니다\"\n",
    "grad_on = []\n",
    "h5 = m5.register_forward_hook(lambda mod, inp, out: grad_on.append(torch.is_grad_enabled()))\n",
    "evaluate(m5, Xv_t, yv_t, loss_fn); h5.remove()\n",
    "assert grad_on and not any(grad_on), \"평가 중 기울기 기록이 켜져 있습니다. torch.no_grad() 안에서 계산하세요\"\n",
    "m5d = nn.Sequential(nn.Linear(30, 16), nn.ReLU(), nn.Dropout(0.5), nn.Linear(16, 1)); m5d.train()\n",
    "r1, r2 = evaluate(m5d, Xv_t, yv_t, loss_fn), evaluate(m5d, Xv_t, yv_t, loss_fn)\n",
    "assert r1 == r2, \"드롭아웃 모델에서 평가할 때마다 값이 다릅니다. model.eval()을 부르세요\"\n",
    "yz = torch.zeros(4, 1); zz = torch.tensor([[-1.0], [0.0], [2.0], [-3.0]])\n",
    "class Fixed(nn.Module):\n",
    "    def forward(self, x):\n",
    "        return zz\n",
    "assert np.isclose(evaluate(Fixed(), torch.zeros(4, 2), yz, loss_fn)[1], 0.75), \"점수 0은 0으로 예측합니다(z > 0만 1)\"\n",
    "print(f\"학습 전 검증 손실 {l5:.3f}, 정확도 {a5:.3f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-017",
   "metadata": {},
   "source": [
    "## 문제 6. 가장 좋은 에폭 남기기 (코드)\n",
    "\n",
    "`fit_best(model, train_loader, X_va, y_va, optimizer, loss_fn, epochs, patience)`를 쓰세요. 문제 4·5 함수를 씁니다.\n",
    "\n",
    "- 에폭마다 `train_one_epoch` 뒤 `evaluate`로 검증 손실을 재고, `history`에 `(훈련 평균 손실, 검증 손실)`을 붙입니다.\n",
    "- 검증 손실이 지금까지보다 **작아지면**(`<`) 그 에폭 번호(1부터)와 모델 매개변수의 **복사본**을 기억합니다.\n",
    "- 가장 좋았던 에폭 뒤로 `patience` 에폭 동안 나아지지 않으면 멈춥니다(조기 종료). `epochs`에 닿아도 멈춥니다.\n",
    "- 끝나기 전에 모델을 가장 좋았던 매개변수로 되돌리고 `(history, best_epoch)`를 돌려줍니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 11-7절. 복사본은 `copy.deepcopy(model.state_dict())`, 되돌리기는 `model.load_state_dict(best_state)`. 멈춤 조건은 `epoch - best_epoch >= patience`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def fit_best(model, train_loader, X_va, y_va, optimizer, loss_fn, epochs, patience):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "def run6(epochs, patience, seed=0):\n",
    "    m = make_model()\n",
    "    o = torch.optim.Adam(m.parameters(), lr=0.01)\n",
    "    tl6 = DataLoader(train_ds, batch_size=32, shuffle=True, generator=torch.Generator().manual_seed(seed))\n",
    "    return m, fit_best(m, tl6, Xv_t, yv_t, o, loss_fn, epochs, patience)\n",
    "\n",
    "m6, res6 = run6(60, 10)\n",
    "assert res6 is not None, \"결과를 return 하세요\"\n",
    "hist6, best6 = res6\n",
    "va6 = [v for _, v in hist6]\n",
    "assert isinstance(hist6[0], tuple) and len(hist6[0]) == 2, \"history에는 (훈련 손실, 검증 손실) 튜플을 붙입니다\"\n",
    "assert best6 == int(np.argmin(va6)) + 1, f\"best_epoch {best6} ≠ 검증 손실이 가장 낮은 에폭 {int(np.argmin(va6)) + 1}(1부터 셉니다)\"\n",
    "assert len(hist6) == best6 + 10, f\"{len(hist6)}에폭에서 멈췄습니다. 최고 에폭 {best6} 뒤 patience 10 에폭 동안 나아지지 않으면 {best6 + 10}에폭에서 멈춥니다\"\n",
    "now = evaluate(m6, Xv_t, yv_t, loss_fn)[0]\n",
    "assert np.isclose(now, min(va6), rtol=1e-6), f\"돌려받은 모델의 검증 손실 {now:.4f} ≠ 최저 {min(va6):.4f}. state_dict는 복사(deepcopy)해서 보관하고 끝에 되돌리세요\"\n",
    "ref_m = make_model(); ref_o = torch.optim.Adam(ref_m.parameters(), lr=0.01)\n",
    "ref_l = DataLoader(train_ds, batch_size=32, shuffle=True, generator=torch.Generator().manual_seed(0))\n",
    "ref_hist = []\n",
    "for _ in range(best6):\n",
    "    ref_tr = train_one_epoch(ref_m, ref_l, ref_o, loss_fn)\n",
    "    ref_hist.append((ref_tr, evaluate(ref_m, Xv_t, yv_t, loss_fn)[0]))\n",
    "assert np.allclose([t for t, _ in hist6[:best6]], [t for t, _ in ref_hist], rtol=1e-6), \"history의 훈련 손실이 에폭마다 train_one_epoch가 돌려준 값과 다릅니다\"\n",
    "assert np.allclose(va6[:best6], [v for _, v in ref_hist], rtol=1e-6), \"history의 검증 손실이 에폭마다 잰 값과 다릅니다\"\n",
    "assert all(torch.allclose(p, q) for p, q in zip(m6.parameters(), ref_m.parameters())), \"돌려받은 모델이 최고 에폭 시점의 매개변수와 다릅니다\"\n",
    "_, (h_short, _) = run6(5, 100)\n",
    "assert len(h_short) == 5, \"patience가 커도 epochs에 닿으면 멈춥니다\"\n",
    "print(f\"최고 에폭 {best6}, 검증 손실 {min(va6):.3f}, 멈춘 에폭 {len(hist6)}, 그때 검증 손실 {va6[-1]:.3f}\")\n",
    "print(\"검증 정확도(최고 에폭 모델)\", round(evaluate(m6, Xv_t, yv_t, loss_fn)[1], 3))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(5.5, 3.2))\n",
    "ax.plot(range(1, len(hist6) + 1), [t for t, _ in hist6], label=\"훈련 평균 손실\")\n",
    "ax.plot(range(1, len(hist6) + 1), va6, label=\"검증 손실\")\n",
    "ax.axvline(best6, color=\"gray\", ls=\":\"); ax.set_xlabel(\"에폭\"); ax.legend(); ax.set_title(\"조기 종료\")\n",
    "plt.show()\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-020",
   "metadata": {},
   "source": [
    "## 문제 7. 체크포인트 저장·재로딩 (코드)\n",
    "\n",
    "두 함수를 쓰세요.\n",
    "\n",
    "1. `save_checkpoint(path, model, optimizer, epoch, scaler)`: 딕셔너리 하나를 `torch.save`로 저장합니다. 키는 `\"model\"`(모델 `state_dict`), `\"optimizer\"`(옵티마이저 `state_dict`), `\"epoch\"`(정수), `\"scaler_mean\"`·`\"scaler_scale\"`(표준화 평균·표준편차, **리스트**로).\n",
    "2. `load_checkpoint(path, model, optimizer)`: `torch.load(path, weights_only=True)`로 읽어 모델·옵티마이저에 상태를 넣고, `(epoch, 평균 NumPy 배열, 표준편차 NumPy 배열)`을 돌려줍니다.\n",
    "\n",
    "`scaler` 객체를 통째로 넣으면 `weights_only=True`로 읽을 수 없습니다. 숫자 리스트로 바꿔 넣으세요.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`scaler.mean_.tolist()`, `scaler.scale_.tolist()`. 읽을 때 `model.load_state_dict(ck[\"model\"])`, `optimizer.load_state_dict(ck[\"optimizer\"])`, `np.array(ck[\"scaler_mean\"])`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def save_checkpoint(path, model, optimizer, epoch, scaler):\n",
    "    pass   # 작성\n",
    "\n",
    "def load_checkpoint(path, model, optimizer):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-022",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "def loader7(seed):\n",
    "    return DataLoader(train_ds, batch_size=32, shuffle=True, generator=torch.Generator().manual_seed(seed))\n",
    "\n",
    "path7 = os.path.join(tempfile.mkdtemp(), \"cancer.pt\")\n",
    "m7 = make_model(); o7 = torch.optim.Adam(m7.parameters(), lr=0.01)\n",
    "for s in range(3):\n",
    "    train_one_epoch(m7, loader7(s), o7, loss_fn)\n",
    "save_checkpoint(path7, m7, o7, 3, scaler)\n",
    "assert os.path.exists(path7), \"파일이 저장되지 않았습니다\"\n",
    "raw = torch.load(path7, weights_only=True)\n",
    "assert isinstance(raw, dict) and {\"model\", \"optimizer\", \"epoch\", \"scaler_mean\", \"scaler_scale\"} <= set(raw), f\"키가 {sorted(raw) if isinstance(raw, dict) else type(raw)}입니다\"\n",
    "assert raw[\"epoch\"] == 3 and type(raw[\"epoch\"]) is int, f\"epoch는 정수 3으로 저장합니다(지금 {raw['epoch']!r})\"\n",
    "assert isinstance(raw[\"scaler_mean\"], list) and isinstance(raw[\"scaler_scale\"], list), \"표준화 평균·표준편차는 리스트로 저장합니다(.tolist())\"\n",
    "assert np.allclose(raw[\"scaler_mean\"], scaler.mean_) and np.allclose(raw[\"scaler_scale\"], scaler.scale_), \"표준화 값이 다릅니다\"\n",
    "\n",
    "m7b = make_model(seed=42); o7b = torch.optim.Adam(m7b.parameters(), lr=0.01)    # 다른 난수로 만든 새 객체\n",
    "res7 = load_checkpoint(path7, m7b, o7b)\n",
    "assert res7 is not None, \"load_checkpoint: 결과를 return 하세요\"\n",
    "ep7, mean7, scale7 = res7\n",
    "assert ep7 == 3 and isinstance(mean7, np.ndarray) and isinstance(scale7, np.ndarray), \"(epoch, 평균 배열, 표준편차 배열)을 돌려주세요\"\n",
    "assert np.allclose(mean7, scaler.mean_) and np.allclose(scale7, scaler.scale_), \"돌려준 평균·표준편차가 저장한 값과 다릅니다(순서: 평균, 표준편차)\"\n",
    "x_raw = X_va[:5]                                   # 원래 단위의 새 표본: 저장한 값으로 표준화\n",
    "x_in = torch.tensor((x_raw - mean7) / scale7, dtype=torch.float32)\n",
    "m7.eval(); m7b.eval()\n",
    "with torch.no_grad():\n",
    "    assert torch.equal(m7(x_in), m7b(x_in)), \"불러온 모델의 예측이 저장한 모델과 다릅니다\"\n",
    "for s in range(3, 5):                              # 둘 다 같은 순서로 2에폭 더\n",
    "    train_one_epoch(m7, loader7(s), o7, loss_fn)\n",
    "    train_one_epoch(m7b, loader7(s), o7b, loss_fn)\n",
    "assert all(torch.equal(p, q) for p, q in zip(m7.parameters(), m7b.parameters())), \"이어서 학습한 결과가 끊지 않은 학습과 다릅니다. 옵티마이저 상태도 저장·복원하세요\"\n",
    "print(\"저장 키\", sorted(raw), \"/ 이어서 학습해도 같음\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-023",
   "metadata": {},
   "source": [
    "## 문제 8. 옵티마이저·학습 보조 기법 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q8`에 적으세요.\n",
    "\n",
    "(a) Adam은 기울기의 이동 평균과 기울기 제곱의 이동 평균을 써서 매개변수마다 갱신 폭을 따로 정한다.\n",
    "(b) 모멘텀 0.9인 SGD는 지난 갱신 방향을 이어 가므로, 기울기 방향이 계속 같으면 같은 학습률의 모멘텀 없는 SGD보다 크게 움직인다.\n",
    "(c) `model.eval()`을 부르면 기울기 기록도 꺼지므로 평가에서 `torch.no_grad()`는 필요 없다.\n",
    "(d) 드롭아웃은 평가 때도 유닛을 무작위로 꺼서 과적합을 막는다.\n",
    "(e) Adam으로 학습하다 끊겼을 때, 모델 `state_dict`만 저장해 두면 이어서 학습해도 끊지 않은 학습과 같은 결과가 나온다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q8 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"4a2e740d6ccd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-026",
   "metadata": {},
   "source": [
    "## 문제 9. 학습 곡선 진단 (사례)\n",
    "\n",
    "각 곡선에 가장 알맞은 진단을 고르세요. (a)~(e) 순서대로 이어 쓴 문자열을 `q9`에 적으세요.\n",
    "\n",
    "- `U`: 과소적합 → 학습률·에폭을 늘리거나 모델을 키운다\n",
    "- `O`: 과적합 → 검증 손실이 가장 낮은 에폭을 쓰고(조기 종료), 데이터·규제를 검토한다\n",
    "- `L`: 발산 → 학습률을 낮추고 `zero_grad`·입력 스케일을 확인한다\n",
    "- `M`: 측정 방식 차이 → 같은 시점·같은 모드(`eval`)로 다시 잰다\n",
    "\n",
    "(a) SGD(lr=0.001)로 50에폭. 훈련 손실 0.66 → 0.58, 검증 손실 0.67 → 0.59로 둘 다 천천히 내려가는 중이다.\n",
    "(b) 훈련 손실 0.30 → 0.02로 계속 내려간다. 검증 손실은 12에폭에 0.25로 가장 낮았다가 60에폭에 0.90이다.\n",
    "(c) 에폭별 훈련 손실이 0.41, 0.95, 0.33, 2.7, 8.1, `nan`이다.\n",
    "(d) 드롭아웃(p=0.5)이 있는 모델. 에폭 평균 훈련 손실(학습 중 기록) 0.45, 검증 손실 0.20. 훈련 데이터를 `eval()` 모드로 다시 재니 0.18이다.\n",
    "(e) 검증 정확도는 0.95 근처에서 거의 그대로인데, 검증 손실은 0.12에서 0.40으로 오른다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"30ffcd03880d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-029",
   "metadata": {},
   "source": [
    "## 문제 10. 상황별 설정 (사례)\n",
    "\n",
    "각 상황에 가장 알맞은 것을 고르세요. (a)~(e) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "- `A`: Adam(lr 0.001~0.01)으로 시작해 학습이 되는지 확인\n",
    "- `D`: 직접 만든 `Dataset`의 `__getitem__`에서 파일을 하나씩 읽는다\n",
    "- `C`: 에폭마다 모델·옵티마이저 `state_dict`, 에폭, 전처리 값을 저장\n",
    "- `B`: 마지막 층은 점수를 내고 `BCEWithLogitsLoss`를 쓴다\n",
    "- `E`: 매 에폭 검증 손실을 재고 가장 낮은 에폭의 매개변수를 복사해 둔다\n",
    "\n",
    "(a) 새 MLP를 처음 학습한다. 옵티마이저와 학습률을 아직 정하지 않았다.\n",
    "(b) 이미지 파일 5만 장이 폴더에 있고, 한꺼번에 메모리에 올릴 수 없다.\n",
    "(c) 학습이 6시간 걸리고, 공용 PC라 중간에 꺼질 수 있다. 꺼지면 이어서 학습해야 한다.\n",
    "(d) 모델 끝에 `nn.Sigmoid()`를 두고 로그 손실을 직접 계산했더니, 가끔 손실이 `inf`가 된다.\n",
    "(e) 200에폭 학습했는데 검증 손실이 40에폭부터 오른다. 어느 시점의 모델을 쓸지 정해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"52b99904e65c\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-032",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 4에서 `optimizer.zero_grad()`를 지우고 점검 셀이 실패하는 것을 확인했다.\n",
    "- [ ] 문제 6에서 `copy.deepcopy`를 빼면 돌려받은 모델의 검증 손실이 어떻게 되는지 확인했다.\n",
    "- [ ] 문제 6을 `torch.optim.SGD(..., lr=0.1, momentum=0.9)`로 바꿔 최고 에폭과 검증 손실을 비교했다.\n",
    "- [ ] 원고 11-12절 선택 기준표의 여섯 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(12장)에서는 이 루프 그대로 합성곱 신경망(CNN)을 이미지 데이터에 학습한다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
