{
 "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 = \"OXXOX\""
   ]
  },
  {
   "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": [
    "> **해설**\n",
    ">\n",
    "> (a) ⌈426 / 32⌉ = 14(32 × 13 = 416, 마지막 배치 10개). (b) 배치가 크면 스텝 수는 **줄어든다**. (c) 에폭마다 새로 섞는다(원고 11-4절 0~9 예). (d) 미니배치 기울기는 전체 기울기를 중심으로 흔들리는 추정값이다(원고 11-3절). (e) 검증 손실은 모든 표본의 평균이라 순서와 상관없다. 섞지 않아야 예측을 원래 행과 맞추기 쉽다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-006",
   "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-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "class TabularDataset(Dataset):\n",
    "    def __init__(self, X, y):\n",
    "        self.X = torch.tensor(X, dtype=torch.float32)\n",
    "        self.y = torch.tensor(y, dtype=torch.float32).reshape(-1, 1)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.X)\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        return self.X[i], self.y[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-008",
   "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-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `Dataset`은 \"몇 개인가\"와 \"i번째는 무엇인가\"만 정한다. 배치 축은 `DataLoader`가 표본을 쌓아(stack) 붙인다. 표본 하나의 정답을 `(1,)`로 두면 배치가 `(B, 1)`이 되어 모델 출력 `(B, 1)`과 모양이 맞는다. 데이터가 메모리에 이미 있으면 `TensorDataset`으로도 충분하지만, 이미지 파일처럼 하나씩 읽어야 하는 데이터는 이 틀의 `__getitem__` 안에서 읽는다(12장)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-010",
   "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-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def make_loaders(train_ds, val_ds, batch_size, seed):\n",
    "    g = torch.Generator().manual_seed(seed)\n",
    "    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True, generator=g)\n",
    "    val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False)\n",
    "    return train_loader, val_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-012",
   "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-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `generator`에 seed를 준 전용 `torch.Generator`를 넘기면 섞는 순서가 전역 난수와 상관없이 재현된다. 같은 로더를 다시 돌리면 generator 상태가 이어져 에폭마다 다른 순서가 나온다. 426개를 32개씩이면 14스텝, 마지막 배치는 10개다. 검증 로더는 순서를 바꾸지 않으므로, 예측을 모아 원래 행과 나란히 둘 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-014",
   "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-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def train_one_epoch(model, loader, optimizer, loss_fn):\n",
    "    model.train()\n",
    "    total, n = 0.0, 0\n",
    "    for xb, yb in loader:\n",
    "        optimizer.zero_grad()\n",
    "        loss = loss_fn(model(xb), yb)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total += loss.item() * len(xb)\n",
    "        n += len(xb)\n",
    "    return total / n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-016",
   "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-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 옵티마이저가 갱신(`step`)과 기울기 비우기(`zero_grad`)를 맡으므로 루프는 모델이 바뀌어도 그대로다. `zero_grad`를 빼면 기울기가 쌓여 매개변수가 기준 구현과 달라진다(10장 10-9절). 마지막 배치(10개)는 다른 배치(32개)보다 작아서, 배치 평균들을 그냥 평균하면 마지막 배치의 표본 하나하나가 더 큰 비중을 갖는다. 이 평균 손실은 에폭 **도중** 매개변수가 바뀌는 동안 잰 값이므로, 같은 시점의 정확한 손실은 문제 5의 평가 함수로 따로 잰다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-018",
   "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-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def evaluate(model, X, y, loss_fn):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        z = model(X)\n",
    "        loss = loss_fn(z, y).item()\n",
    "        acc = ((z > 0).float() == y).float().mean().item()\n",
    "    return loss, acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-020",
   "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-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `eval()`은 드롭아웃·배치 정규화의 **동작**을 평가용으로 바꾸고, `no_grad()`는 **기록**을 끈다(원고 11-9절). 하나만 쓰면 점검이 걸린다. 점수 z = 0은 확률 정확히 0.5라 1로 보지 않는다(z > 0 ⇔ σ(z) > 0.5). 06장 `predict`처럼 0.5 이상을 1로 보는 약속도 있으므로, 경계값을 어떻게 다루는지는 코드마다 확인한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-022",
   "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-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def fit_best(model, train_loader, X_va, y_va, optimizer, loss_fn, epochs, patience):\n",
    "    history, best_loss, best_epoch, best_state = [], float(\"inf\"), 0, None\n",
    "    for epoch in range(1, epochs + 1):\n",
    "        tr = train_one_epoch(model, train_loader, optimizer, loss_fn)\n",
    "        va = evaluate(model, X_va, y_va, loss_fn)[0]\n",
    "        history.append((tr, va))\n",
    "        if va < best_loss:\n",
    "            best_loss, best_epoch = va, epoch\n",
    "            best_state = copy.deepcopy(model.state_dict())\n",
    "        if epoch - best_epoch >= patience:\n",
    "            break\n",
    "    model.load_state_dict(best_state)\n",
    "    return history, best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-024",
   "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-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `state_dict()`는 매개변수를 가리키기만 하므로, 복사하지 않고 보관하면 학습이 이어지는 동안 같이 바뀌어 결국 마지막 에폭 값이 된다. 그래서 `copy.deepcopy`가 필요하다. 이 데이터에서는 검증 손실이 몇 에폭 만에 바닥을 찍고 다시 오른다. 데이터가 426개로 적고 MLP가 금방 훈련 데이터를 외우기 때문이다. 최고 에폭 모델의 검증 정확도는 로지스틱 회귀(약 0.96)와 비슷하다. 표 데이터에서 MLP가 늘 이기지 않는다는 10장 기준표 그대로다. 실제로는 이 검증 데이터를 에폭 선택에 썼으므로, 최종 성능은 따로 남겨 둔 테스트 데이터로 잰다(05장)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-026",
   "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-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def save_checkpoint(path, model, optimizer, epoch, scaler):\n",
    "    torch.save({\"model\": model.state_dict(), \"optimizer\": optimizer.state_dict(), \"epoch\": epoch,\n",
    "                \"scaler_mean\": scaler.mean_.tolist(), \"scaler_scale\": scaler.scale_.tolist()}, path)\n",
    "\n",
    "def load_checkpoint(path, model, optimizer):\n",
    "    ck = torch.load(path, weights_only=True)\n",
    "    model.load_state_dict(ck[\"model\"])\n",
    "    optimizer.load_state_dict(ck[\"optimizer\"])\n",
    "    return ck[\"epoch\"], np.array(ck[\"scaler_mean\"]), np.array(ck[\"scaler_scale\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-028",
   "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-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 옵티마이저 상태(Adam의 m·v와 스텝 수)를 빼면 불러온 직후 예측은 같아도, 이어서 학습한 결과가 달라진다(원고 11-8절). `weights_only=True`는 텐서·숫자·문자열·리스트·딕셔너리만 읽어, 출처를 모르는 파일 안의 코드가 실행되는 것을 막는다. 그래서 `StandardScaler` 객체 대신 숫자 리스트로 넣었다. 새 표본은 원래 단위로 들어오므로 저장한 평균·표준편차로 똑같이 표준화한 뒤 모델에 넣는다. 09장 `Pipeline` 저장과 같은 이유다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-030",
   "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-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q8 = \"OOXXX\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"4a2e740d6ccd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) m(1차)·v(2차) 이동 평균, w ← w − η·m̂ / (√v̂ + ε)(원고 11-10절). (b) 같은 기울기 g가 이어지면 v는 g/(1 − 0.9) = 10g로 다가간다. (c) `eval()`은 층의 동작만 바꾸고 기록은 끄지 않는다. 둘 다 쓴다. (d) 드롭아웃은 **훈련 때만** 끄고 평가 때는 그대로 통과시킨다. (e) 옵티마이저 상태가 없으면 Adam의 m·v가 0에서 다시 시작해 경로가 달라진다(문제 7)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-034",
   "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-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"UOLMO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"30ffcd03880d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 둘 다 높고 아직 내려가는 중이면 덜 학습된 것이다. (b) 훈련과 검증이 벌어지는 전형적인 과적합. (c) 손실이 오르내리다 커지고 `nan`이면 발산이다(원고 11-7절 표). (d) 학습 중 기록한 손실은 드롭아웃이 켜진 채, 매개변수가 바뀌는 도중에 잰 값이다. 같은 모드로 다시 재면 0.18로 검증 손실과 비슷하다. 과소적합이 아니다. (e) 정확도는 그대로여도 틀리는 표본에 지나치게 확신하게 된 과적합이다(원고 11-7절). 정확도만 보면 놓친다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-038",
   "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-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"ADCBE\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch11-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"52b99904e65c\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-041",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) Adam은 학습률에 덜 민감해 처음 시도로 알맞다. 잘 되면 SGD+모멘텀과 비교한다. (b) `TensorDataset`은 데이터를 모두 메모리에 올려야 한다. 파일 경로 목록만 들고 `__getitem__`에서 읽는다(12장). (c) 이어서 학습하려면 옵티마이저 상태까지 필요하다(문제 7). (d) float32에서 σ(z)가 0이나 1로 반올림되면 log 0 = −∞다. 점수를 받는 손실은 이 계산을 안정하게 한다(원고 11-5·11-10절). (e) 조기 종료와 최고 에폭 보관(문제 6). 다음 학습부터는 인내 에폭을 정해 일찍 멈춘다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch11-042",
   "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
}
