{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch10-000",
   "metadata": {},
   "source": [
    "# 10장 실습. 신경망과 역전파\n",
    "\n",
    "**목표:** NumPy 데이터를 텐서로 바꾸고, tanh 은닉층 MLP의 순전파·역전파·학습 루프를 직접 쓴 뒤 수치 미분과 PyTorch autograd로 검산한다. 직접 학습한 매개변수를 `nn.Sequential`로 옮기고, 학습이 안 되는 신경망을 진단한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 배열·딕셔너리를 바꾸지 않고** 새 값을 돌려준다.\n",
    "- 문제 5·6·7은 문제 4의 함수를, 문제 6은 문제 5의 함수를 쓴다. 순서대로 푼다.\n",
    "- 원고(10장)는 은닉층에 ReLU를 썼고, 이 실습은 **tanh**를 쓴다. 미분 한 곳만 다르다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch import nn\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.special import expit\n",
    "from sklearn.datasets import make_moons\n",
    "from sklearn.model_selection import train_test_split\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",
    "def sigmoid(z):\n",
    "    return expit(z)                                # 넘침 없는 시그모이드(06장 실습 문제 2)\n",
    "\n",
    "def bce(y, p):\n",
    "    return float(-np.mean(y * np.log(p) + (1 - y) * np.log(1 - p)))\n",
    "\n",
    "def init_params(d, h, seed):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    return {\"W1\": rng.normal(0, 1 / np.sqrt(d), (d, h)), \"b1\": np.zeros(h),\n",
    "            \"w2\": rng.normal(0, 1 / np.sqrt(h), h), \"b2\": 0.0}\n",
    "\n",
    "# 반달 두 개가 맞물린 데이터: 직선 하나로는 못 나눈다. 두 좌표의 크기가 비슷해 표준화는 생략\n",
    "Xm, ym = make_moons(n_samples=400, noise=0.15, random_state=0)\n",
    "m_tr, m_va, ym_tr, ym_va = train_test_split(Xm, ym, test_size=0.3, stratify=ym, random_state=0)\n",
    "print(\"훈련\", m_tr.shape, \"검증\", m_va.shape, \"/ 1의 비율\", ym.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-002",
   "metadata": {},
   "source": [
    "## 문제 1. 텐서·autograd 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q1`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) `torch.tensor([1.0, 2.0])`의 dtype은 NumPy처럼 `float64`다.\n",
    "(b) `t = torch.from_numpy(a)`로 만든 텐서는 그 뒤 `a[0] = 7`을 하면 함께 바뀐다.\n",
    "(c) 같은 텐서에서 `backward()`를 두 번 부르면 `.grad`에는 두 번째 기울기만 남는다.\n",
    "(d) 경사하강법 갱신 `w -= lr * w.grad`는 `torch.no_grad()` 안에서 한다.\n",
    "(e) `requires_grad=False`인 매개변수는 `backward()` 뒤에도 기울기가 생기지 않아, 경사하강법으로 갱신되지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q1 = \"XOXOO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"82d8e70f5137\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-005",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) PyTorch의 기본 실수 dtype은 `float32`다(원고 10-3절). (b) `from_numpy`는 메모리를 공유한다. `torch.tensor(a)`는 복사한다. (c) 기울기는 **더해진다**. 그래서 스텝마다 비운다. (d) 갱신을 기록 밖에서 해야 잎 텐서 제자리 수정 오류가 나지 않고, 갱신이 그래프에 남지 않는다. (e) 기울기가 없으면 갱신할 값도 없다. 15장의 동결이 이 원리다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-006",
   "metadata": {},
   "source": [
    "## 문제 2. NumPy 데이터를 모델 입력 텐서로 (코드)\n",
    "\n",
    "`to_tensors(X, y)`를 쓰세요. NumPy 특성 `X`(N, d)와 정답 `y`(N,)를 받아 `(Xt, yt)`를 돌려줍니다.\n",
    "\n",
    "- `Xt`: dtype `torch.float32`, 모양 `(N, d)`\n",
    "- `yt`: dtype `torch.float32`, 모양 `(N, 1)` (모델 출력 `(N, 1)`과 같은 모양, 원고 10-10절 모양 함정)\n",
    "- 둘 다 **복사본**이어야 합니다. 나중에 `X`를 바꿔도 `Xt`는 그대로여야 합니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`torch.tensor(X, dtype=torch.float32)`는 복사하며 dtype을 바꿉니다. `y`는 같은 방법으로 바꾼 뒤 `.reshape(-1, 1)` 또는 `.unsqueeze(1)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def to_tensors(X, y):\n",
    "    Xt = torch.tensor(X, dtype=torch.float32)\n",
    "    yt = torch.tensor(y, dtype=torch.float32).reshape(-1, 1)\n",
    "    return Xt, yt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-008",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "Xa, ya = m_tr[:5].copy(), ym_tr[:5].copy()\n",
    "X0, y0 = Xa.copy(), ya.copy()\n",
    "res2 = to_tensors(Xa, ya)\n",
    "assert res2 is not None, \"결과를 return 하세요\"\n",
    "Xt2, yt2 = res2\n",
    "assert np.array_equal(Xa, X0) and np.array_equal(ya, y0), \"입력 배열이 바뀌었습니다\"\n",
    "assert isinstance(Xt2, torch.Tensor) and isinstance(yt2, torch.Tensor), \"둘 다 torch.Tensor여야 합니다\"\n",
    "assert Xt2.dtype == torch.float32, f\"Xt dtype이 {Xt2.dtype}입니다. float32로 바꾸세요\"\n",
    "assert yt2.dtype == torch.float32, f\"yt dtype이 {yt2.dtype}입니다. 정답도 손실 계산에 쓰므로 float32로\"\n",
    "assert tuple(Xt2.shape) == (5, 2), f\"Xt 모양이 {tuple(Xt2.shape)}입니다\"\n",
    "assert tuple(yt2.shape) == (5, 1), f\"yt 모양이 {tuple(yt2.shape)}입니다. (N, 1)로 바꾸세요\"\n",
    "assert np.allclose(Xt2.numpy(), Xa) and np.array_equal(yt2.numpy().ravel(), ya), \"값이 원래 배열과 다릅니다\"\n",
    "Xa[0, 0] = 999.0\n",
    "assert Xt2[0, 0].item() != 999.0, \"X를 바꿨더니 Xt도 바뀌었습니다. torch.from_numpy는 메모리를 공유합니다. 복사하세요\"\n",
    "Xf = m_tr[:3].astype(np.float32)                   # 이미 float32인 입력도 복사해야 한다\n",
    "Xtf, _ = to_tensors(Xf, ym_tr[:3])\n",
    "Xf[0, 0] = 999.0\n",
    "assert Xtf[0, 0].item() != 999.0, \"float32 입력에서 X를 바꿨더니 Xt도 바뀌었습니다. dtype이 같으면 .float()는 복사하지 않습니다\"\n",
    "yf = ym_tr[:3].astype(np.float32)                  # 정답도 복사본이어야 한다\n",
    "_, ytf = to_tensors(m_tr[:3], yf)\n",
    "yf[0] = 7.0\n",
    "assert ytf[0, 0].item() != 7.0, \"float32 정답에서 y를 바꿨더니 yt도 바뀌었습니다. 정답도 torch.tensor로 복사하세요\"\n",
    "Xt_tr, yt_tr = to_tensors(m_tr, ym_tr)\n",
    "print(Xt_tr.shape, Xt_tr.dtype, yt_tr.shape)\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `torch.tensor`는 늘 복사하므로 원본과 독립이다. `torch.from_numpy(X).float()`도 dtype이 바뀌면서 복사가 일어나 결과는 같지만, dtype이 이미 float32인 배열이면 `.float()`가 복사하지 않아 메모리를 공유한다. 의도가 드러나는 `torch.tensor(..., dtype=...)`가 안전하다. 정답을 `(N, 1)`로 두는 것은 출력이 `(N, 1)`인 `nn.Linear(h, 1)` 모델과 모양을 맞추기 위해서다. 정답이 `(N,)`이면 `(N, 1) − (N,)`이 `(N, N)`으로 브로드캐스팅된다(원고 10-10절). 11장 `BCEWithLogitsLoss`는 두 입력의 모양이 다르면 오류를 내 주지만, 직접 쓴 손실 식은 오류 없이 틀린다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-010",
   "metadata": {},
   "source": [
    "## 문제 3. 활성화 함수의 미분 (코드)\n",
    "\n",
    "`act_grads(z)`를 쓰세요. NumPy 배열 `z`를 받아 세 활성화 함수의 **미분**을 딕셔너리로 돌려줍니다.\n",
    "\n",
    "`{\"sigmoid\": σ′(z), \"tanh\": tanh′(z), \"relu\": ReLU′(z)}` (모두 `z`와 같은 모양의 float 배열)\n",
    "\n",
    "- 원고 10-5절 표의 식을 씁니다. `sigmoid` 함수는 위 준비 셀에 있습니다.\n",
    "- ReLU의 미분은 z > 0이면 1, 그 밖(z = 0 포함)은 0입니다(PyTorch와 같은 약속).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`s = sigmoid(z)` → `s * (1 - s)`, `1 - np.tanh(z) ** 2`, `(z > 0).astype(float)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def act_grads(z):\n",
    "    s = sigmoid(z)\n",
    "    return {\"sigmoid\": s * (1 - s), \"tanh\": 1 - np.tanh(z) ** 2, \"relu\": (z > 0).astype(float)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "z3 = np.array([-3.0, -0.5, 0.0, 0.5, 3.0])\n",
    "z30 = z3.copy()\n",
    "g3 = act_grads(z3)\n",
    "assert g3 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(z3, z30), \"입력 배열이 바뀌었습니다\"\n",
    "assert set(g3) == {\"sigmoid\", \"tanh\", \"relu\"}, f\"키가 {sorted(g3)}입니다\"\n",
    "zt3 = torch.tensor(z3, requires_grad=True)\n",
    "for name, f in [(\"sigmoid\", torch.sigmoid), (\"tanh\", torch.tanh), (\"relu\", torch.relu)]:\n",
    "    zt3.grad = None\n",
    "    f(zt3).sum().backward()\n",
    "    assert np.shape(g3[name]) == z3.shape, f\"{name}: 모양이 {np.shape(g3[name])}입니다\"\n",
    "    assert np.allclose(g3[name], zt3.grad.numpy()), f\"{name}: {np.round(g3[name], 4)} ≠ autograd {np.round(zt3.grad.numpy(), 4)}\"\n",
    "    print(f\"{name:7s}\", np.round(g3[name], 3))\n",
    "Z3 = np.random.default_rng(3).normal(0, 2, (4, 6))\n",
    "assert np.allclose(act_grads(Z3)[\"tanh\"], 1 - np.tanh(Z3) ** 2) and np.shape(act_grads(Z3)[\"relu\"]) == (4, 6), \"2차원 입력에서도 원소별로 계산하세요\"\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 시그모이드 미분은 z = 0에서 최대 0.25이고 |z| = 3이면 0.045로 작다. tanh는 0에서 1이라 기울기를 덜 줄인다. ReLU는 켜지면 1, 꺼지면 0이다. 세 미분 모두 **순전파에서 이미 계산한 값**(σ(z), tanh(z), z의 부호)으로 계산된다는 점이 중요하다. 그래서 역전파는 순전파 값을 저장해 두고 쓴다. 문제 5에서 tanh 미분을 `1 - H ** 2`(H = tanh(A))로 쓰는 것도 이 때문이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-014",
   "metadata": {},
   "source": [
    "## 문제 4. tanh 은닉층 MLP의 순전파 (코드)\n",
    "\n",
    "`forward_tanh(X, P)`를 쓰세요. 매개변수 딕셔너리 `P`(`init_params`와 같은 키 `W1`·`b1`·`w2`·`b2`)로 원고 10-6절 표의 계산을 하되, 은닉층 활성화를 **tanh**로 합니다.\n",
    "\n",
    "A = XW₁ + b₁, H = tanh(A), z = Hw₂ + b₂, p = σ(z)\n",
    "\n",
    "중간값을 `{\"A\": A, \"H\": H, \"z\": z, \"p\": p}`로 돌려줍니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 `forward`에서 `np.maximum(A, 0)`을 `np.tanh(A)`로, 시그모이드는 준비 셀의 `sigmoid`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def forward_tanh(X, P):\n",
    "    A = X @ P[\"W1\"] + P[\"b1\"]\n",
    "    H = np.tanh(A)\n",
    "    z = H @ P[\"w2\"] + P[\"b2\"]\n",
    "    return {\"A\": A, \"H\": H, \"z\": z, \"p\": sigmoid(z)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "P4 = init_params(2, 8, seed=0)\n",
    "P40 = {k: np.copy(v) for k, v in P4.items()}\n",
    "c4 = forward_tanh(m_tr, P4)\n",
    "assert c4 is not None, \"결과를 return 하세요\"\n",
    "assert all(np.array_equal(P4[k], P40[k]) for k in P4), \"매개변수가 바뀌었습니다\"\n",
    "assert set(c4) == {\"A\", \"H\", \"z\", \"p\"}, f\"키가 {sorted(c4)}입니다\"\n",
    "assert {k: np.shape(v) for k, v in c4.items()} == {\"A\": (280, 8), \"H\": (280, 8), \"z\": (280,), \"p\": (280,)}, f\"모양이 {({k: np.shape(v) for k, v in c4.items()})}입니다\"\n",
    "Ps = {\"W1\": np.array([[1.0, -1.0], [0.5, 2.0]]), \"b1\": np.array([0.1, -0.2]), \"w2\": np.array([2.0, -1.0]), \"b2\": 0.3}\n",
    "cs = forward_tanh(np.array([[1.0, 0.0], [0.0, 1.0]]), Ps)\n",
    "Hs = np.tanh(np.array([[1.1, -1.2], [0.6, 1.8]]))\n",
    "assert np.allclose(cs[\"A\"], [[1.1, -1.2], [0.6, 1.8]]), f\"작은 예의 A가 {np.round(cs['A'], 4)}입니다. A = XW1 + b1(활성화 전)\"\n",
    "assert np.allclose(cs[\"H\"], Hs), f\"작은 예의 H가 {np.round(cs['H'], 4)}입니다. 은닉층은 tanh(XW1 + b1)\"\n",
    "assert np.allclose(cs[\"z\"], Hs @ Ps[\"w2\"] + 0.3), \"작은 예의 z가 다릅니다. z = Hw2 + b2(시그모이드 전)\"\n",
    "assert np.allclose(cs[\"p\"], expit(Hs @ Ps[\"w2\"] + 0.3)), \"작은 예의 p가 다릅니다. 출력층은 σ(Hw2 + b2)\"\n",
    "T4 = {k: torch.tensor(v) for k, v in P4.items()}\n",
    "p_ref = torch.sigmoid(torch.tanh(torch.tensor(m_tr) @ T4[\"W1\"] + T4[\"b1\"]) @ T4[\"w2\"] + T4[\"b2\"]).numpy()\n",
    "A_ref = m_tr @ P4[\"W1\"] + P4[\"b1\"]\n",
    "assert np.allclose(c4[\"A\"], A_ref) and np.allclose(c4[\"H\"], np.tanh(A_ref)), \"훈련 데이터에서 A·H가 기준 계산과 다릅니다\"\n",
    "assert np.allclose(c4[\"z\"], np.tanh(A_ref) @ P4[\"w2\"] + P4[\"b2\"]), \"훈련 데이터에서 z가 기준 계산과 다릅니다\"\n",
    "assert np.allclose(c4[\"p\"], p_ref), \"PyTorch로 계산한 확률과 다릅니다\"\n",
    "print(\"학습 전 훈련 손실\", round(bce(ym_tr, c4[\"p\"]), 4))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 학습 전 손실이 log 2 ≈ 0.693 근처인 것은 작은 난수 가중치에서 확률이 대부분 0.5 근처라는 뜻이다. tanh는 출력이 −1~1이고 0 근처에서 거의 직선(tanh(z) ≈ z)이라, 가중치가 작을 때 MLP는 로지스틱 회귀와 비슷하게 시작해 학습하면서 휘어진 경계를 만든다. 중간값 A·H를 함께 돌려주는 것은 다음 문제의 역전파가 쓰기 때문이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-018",
   "metadata": {},
   "source": [
    "## 문제 5. tanh MLP의 역전파 (코드)\n",
    "\n",
    "`backward_tanh(X, y, P, c)`를 쓰세요. 문제 4의 중간값 `c`를 받아 평균 로그 손실의 기울기를 `{\"W1\", \"b1\", \"w2\", \"b2\"}` 딕셔너리로 돌려줍니다. 원고 10-7절 `backward`와 한 줄만 다릅니다.\n",
    "\n",
    "- tanh의 미분은 1 − tanh²(A) = 1 − H² (문제 3).\n",
    "- 각 기울기의 모양은 매개변수의 모양과 같아야 합니다(`b2`는 스칼라).\n",
    "\n",
    "점검 셀은 수치 미분과 PyTorch autograd 두 가지로 비교합니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`dz = (p − y) / N` → `w2`: `H.T @ dz`, `b2`: `dz.sum()` → `dH = np.outer(dz, w2)` → `dA = dH * (1 - H ** 2)` → `W1`: `X.T @ dA`, `b1`: `dA.sum(axis=0)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def backward_tanh(X, y, P, c):\n",
    "    N = len(y)\n",
    "    dz = (c[\"p\"] - y) / N\n",
    "    g = {\"w2\": c[\"H\"].T @ dz, \"b2\": dz.sum()}\n",
    "    dA = np.outer(dz, P[\"w2\"]) * (1 - c[\"H\"] ** 2)\n",
    "    g[\"W1\"] = X.T @ dA\n",
    "    g[\"b1\"] = dA.sum(axis=0)\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-020",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "def numerical_grad(X, y, P, name, h=1e-6):\n",
    "    out = np.zeros(np.shape(P[name]))\n",
    "    for idx in np.ndindex(out.shape):\n",
    "        Q = {k: np.array(v, dtype=float) for k, v in P.items()}\n",
    "        Q[name][idx] += h\n",
    "        up = bce(y, forward_tanh(X, Q)[\"p\"])\n",
    "        Q[name][idx] -= 2 * h\n",
    "        out[idx] = (up - bce(y, forward_tanh(X, Q)[\"p\"])) / (2 * h)\n",
    "    return out\n",
    "\n",
    "P5 = init_params(2, 5, seed=1)\n",
    "X5, y5 = m_tr[:40], ym_tr[:40]\n",
    "c5 = forward_tanh(X5, P5)\n",
    "g5 = backward_tanh(X5, y5, P5, c5)\n",
    "assert g5 is not None, \"결과를 return 하세요\"\n",
    "assert set(g5) == {\"W1\", \"b1\", \"w2\", \"b2\"}, f\"키가 {sorted(g5)}입니다\"\n",
    "for k in P5:\n",
    "    assert np.shape(g5[k]) == np.shape(P5[k]), f\"{k}: 기울기 모양 {np.shape(g5[k])} ≠ 매개변수 모양 {np.shape(P5[k])}\"\n",
    "    num = numerical_grad(X5, y5, P5, k)\n",
    "    assert np.allclose(g5[k], num, rtol=1e-5, atol=1e-8), f\"{k}: 수치 미분과 다릅니다. 최대 차이 {np.abs(g5[k] - num).max():.2e}\"\n",
    "T5 = {k: torch.tensor(v, dtype=torch.float64, requires_grad=True) for k, v in P5.items()}\n",
    "pt5 = torch.sigmoid(torch.tanh(torch.tensor(X5) @ T5[\"W1\"] + T5[\"b1\"]) @ T5[\"w2\"] + T5[\"b2\"])\n",
    "yt5 = torch.tensor(y5, dtype=torch.float64)\n",
    "(-torch.mean(yt5 * torch.log(pt5) + (1 - yt5) * torch.log(1 - pt5))).backward()\n",
    "for k in P5:\n",
    "    assert np.allclose(g5[k], T5[k].grad.numpy()), f\"{k}: autograd와 다릅니다\"\n",
    "print({k: np.shape(v) for k, v in g5.items()})\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> ReLU 버전과 다른 곳은 `dA = dH * (1 - H ** 2)` 한 줄이다. 활성화 함수를 바꾸면 역전파에서는 그 함수의 국소 미분만 바뀌고, 선형 층의 규칙(∂L/∂W = Xᵀ dA, ∂L/∂X = dA Wᵀ)은 그대로다. 수치 미분은 매개변수마다 손실을 두 번 계산하므로 표본 40개, 은닉 5개로 줄여서 비교했다. autograd 비교는 같은 계산을 순전파만 써서 PyTorch가 역전파하게 한 것이다. 두 검산이 모두 통과하면 식이 맞다고 믿을 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-022",
   "metadata": {},
   "source": [
    "## 문제 6. 경사하강법 학습 루프 (코드)\n",
    "\n",
    "`train_tanh(X, y, P, lr=0.5, steps=2000)`을 쓰세요. 문제 4·5의 함수로 전체 배치 경사하강법을 `steps`번 하고 `(학습된 매개변수 딕셔너리, 손실 기록 리스트)`를 돌려줍니다.\n",
    "\n",
    "- 손실 기록은 **갱신 전** 손실을 스텝마다 하나씩 담습니다(길이 `steps`, 원고 10-8절 `train`과 같게).\n",
    "- 입력 `P`는 바꾸지 않습니다(복사본을 학습).\n",
    "\n",
    "점검 셀은 같은 계산을 PyTorch autograd로 한 결과와 매개변수를 비교합니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 10-8절 `train`에서 `forward`·`backward`를 `forward_tanh`·`backward_tanh`로 바꿉니다. 처음에 `P = {k: np.array(v, dtype=float) for k, v in P.items()}`로 복사합니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def train_tanh(X, y, P, lr=0.5, steps=2000):\n",
    "    P = {k: np.array(v, dtype=float) for k, v in P.items()}\n",
    "    history = []\n",
    "    for _ in range(steps):\n",
    "        c = forward_tanh(X, P)\n",
    "        history.append(bce(y, c[\"p\"]))\n",
    "        g = backward_tanh(X, y, P, c)\n",
    "        for k in P:\n",
    "            P[k] = P[k] - lr * g[k]\n",
    "    return P, history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "def train_ref(X, y, P, lr, steps):                 # 점검용: 같은 계산을 autograd로\n",
    "    T = {k: torch.tensor(v, dtype=torch.float64, requires_grad=True) for k, v in P.items()}\n",
    "    Xt, yt = torch.tensor(X), torch.tensor(y, dtype=torch.float64)\n",
    "    hist = []\n",
    "    for _ in range(steps):\n",
    "        p = torch.sigmoid(torch.tanh(Xt @ T[\"W1\"] + T[\"b1\"]) @ T[\"w2\"] + T[\"b2\"])\n",
    "        loss = -torch.mean(yt * torch.log(p) + (1 - yt) * torch.log(1 - p))\n",
    "        hist.append(loss.item())\n",
    "        loss.backward()\n",
    "        with torch.no_grad():\n",
    "            for t in T.values():\n",
    "                t -= lr * t.grad\n",
    "                t.grad.zero_()\n",
    "    return {k: t.detach().numpy() for k, t in T.items()}, hist\n",
    "\n",
    "P6 = init_params(2, 8, seed=0)\n",
    "P60 = {k: np.copy(v) for k, v in P6.items()}\n",
    "res6 = train_tanh(m_tr, ym_tr, P6, lr=0.3, steps=50)\n",
    "assert res6 is not None, \"결과를 return 하세요\"\n",
    "assert all(np.array_equal(P6[k], P60[k]) for k in P6), \"입력 매개변수가 바뀌었습니다. 복사본을 학습하세요\"\n",
    "Pq, hq = res6\n",
    "assert len(hq) == 50, f\"손실 기록 길이가 {len(hq)}입니다. 스텝마다 하나(steps개)\"\n",
    "assert np.isclose(hq[0], bce(ym_tr, forward_tanh(m_tr, P6)[\"p\"])), \"첫 기록은 갱신 전(학습 전) 손실이어야 합니다\"\n",
    "ref6, ref_hist6 = train_ref(m_tr, ym_tr, P6, 0.3, 50)\n",
    "assert np.allclose(hq, ref_hist6), \"손실 기록이 스텝마다 갱신 전 손실과 다릅니다. 스텝마다 그때의 손실을 담으세요\"\n",
    "assert all(np.allclose(Pq[k], ref6[k]) for k in P6), \"lr=0.3, steps=50에서 autograd 학습과 다릅니다. 인자 lr·steps를 그대로 쓰세요\"\n",
    "P_m, hist_m = train_tanh(m_tr, ym_tr, P6)\n",
    "ref_m, _ = train_ref(m_tr, ym_tr, P6, 0.5, 2000)\n",
    "assert all(np.allclose(P_m[k], ref_m[k]) for k in P6), \"기본값(lr=0.5, steps=2000)에서 autograd 학습과 다릅니다\"\n",
    "acc_va = np.mean((forward_tanh(m_va, P_m)[\"p\"] >= 0.5) == ym_va)\n",
    "assert acc_va > 0.95, f\"검증 정확도 {acc_va:.3f}. 로지스틱 회귀(약 0.91)보다 확실히 높아야 합니다\"\n",
    "print(f\"훈련 손실 {hist_m[0]:.3f} → {hist_m[-1]:.3f}, 검증 정확도 {acc_va:.3f}\")\n",
    "\n",
    "g = np.linspace(-2, 3, 200)\n",
    "G1, G2 = np.meshgrid(g, g)\n",
    "prob = forward_tanh(np.c_[G1.ravel(), G2.ravel()], P_m)[\"p\"].reshape(G1.shape)\n",
    "fig, axes = plt.subplots(1, 2, figsize=(9, 3.5))\n",
    "axes[0].contourf(G1, G2, prob, levels=[0, 0.5, 1], colors=[\"#edf2f7\", \"#fed7d7\"])\n",
    "axes[0].scatter(m_va[:, 0], m_va[:, 1], c=ym_va, cmap=\"coolwarm\", s=10)\n",
    "axes[0].set_title(\"검증 데이터와 MLP 경계\")\n",
    "axes[1].plot(hist_m); axes[1].set_xlabel(\"스텝\"); axes[1].set_ylabel(\"훈련 로그 손실\"); axes[1].set_title(\"학습 곡선\")\n",
    "plt.show()\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> NumPy로 직접 쓴 역전파 학습이 autograd 학습과 같은 매개변수에 도착했다. 반달 데이터는 직선 하나로 못 나누지만(로지스틱 회귀는 검증 정확도 약 0.91에 머문다. `LogisticRegression().fit(m_tr, ym_tr).score(m_va, ym_va)`로 직접 확인해 볼 것), 은닉 8개 tanh MLP는 휘어진 경계를 스스로 만든다. 손실 기록을 갱신 **전**에 남기는 이유는 첫 값이 학습 전 상태를 보여 주기 때문이다. 11장에서는 이 루프를 옵티마이저·미니배치로 바꾸고, 검증 손실을 함께 기록해 학습 곡선을 읽는다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-026",
   "metadata": {},
   "source": [
    "## 문제 7. 직접 학습한 MLP를 `nn.Sequential`로 (코드)\n",
    "\n",
    "두 함수를 쓰세요.\n",
    "\n",
    "1. `to_sequential(P)`: 문제 6의 매개변수 딕셔너리로 `nn.Sequential(nn.Linear(d, h), nn.Tanh(), nn.Linear(h, 1))`을 만들고 가중치를 옮겨 돌려줍니다. d·h는 `P[\"W1\"]`의 모양에서 읽습니다.\n",
    "2. `predict_proba_nn(model, X)`: NumPy 특성 `X`(N, d)를 받아 1일 확률을 NumPy `(N,)` 배열로 돌려줍니다. 미분 기록 없이(`torch.no_grad()`) 계산합니다.\n",
    "\n",
    "- `nn.Linear`의 weight 모양은 **(출력 수, 입력 수)**입니다. `W1`은 (d, h)이므로 전치해서 넣습니다(원고 10-10절).\n",
    "- 모델은 float32입니다. 입력도 float32로 바꿔 넣습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`with torch.no_grad():` 안에서 `model[0].weight.copy_(torch.tensor(P[\"W1\"].T))`, `model[0].bias.copy_(...)`, `model[2].weight.copy_(torch.tensor(P[\"w2\"]).reshape(1, -1))`, `model[2].bias.fill_(float(P[\"b2\"]))`. 예측은 `torch.sigmoid(model(Xt)).squeeze(1).numpy()`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def to_sequential(P):\n",
    "    d, h = P[\"W1\"].shape\n",
    "    model = nn.Sequential(nn.Linear(d, h), nn.Tanh(), nn.Linear(h, 1))\n",
    "    with torch.no_grad():\n",
    "        model[0].weight.copy_(torch.tensor(P[\"W1\"].T))\n",
    "        model[0].bias.copy_(torch.tensor(P[\"b1\"]))\n",
    "        model[2].weight.copy_(torch.tensor(P[\"w2\"]).reshape(1, -1))\n",
    "        model[2].bias.fill_(float(P[\"b2\"]))\n",
    "    return model\n",
    "\n",
    "def predict_proba_nn(model, X):\n",
    "    with torch.no_grad():\n",
    "        logits = model(torch.tensor(X, dtype=torch.float32))\n",
    "    return torch.sigmoid(logits).squeeze(1).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "P7 = {k: np.copy(v) for k, v in P_m.items()}\n",
    "model7 = to_sequential(P7)\n",
    "assert model7 is not None, \"to_sequential: 모델을 return 하세요\"\n",
    "assert all(np.array_equal(P7[k], P_m[k]) for k in P7), \"매개변수 딕셔너리가 바뀌었습니다\"\n",
    "assert isinstance(model7, nn.Sequential) and len(model7) == 3, \"nn.Sequential(Linear, Tanh, Linear) 세 층이어야 합니다\"\n",
    "assert isinstance(model7[1], nn.Tanh), f\"가운데 층이 {type(model7[1]).__name__}입니다. 이 실습은 tanh\"\n",
    "assert tuple(model7[0].weight.shape) == (8, 2), f\"첫 층 weight 모양이 {tuple(model7[0].weight.shape)}입니다. (출력 수, 입력 수)\"\n",
    "assert next(model7.parameters()).dtype == torch.float32, \"모델 매개변수는 float32로 둡니다\"\n",
    "p7 = predict_proba_nn(model7, m_va)\n",
    "assert p7 is not None, \"predict_proba_nn: 결과를 return 하세요\"\n",
    "assert isinstance(p7, np.ndarray), f\"NumPy 배열로 돌려주세요(지금 {type(p7).__name__})\"\n",
    "assert p7.shape == (len(m_va),), f\"모양이 {p7.shape}입니다. (N,)으로 squeeze 하세요\"\n",
    "assert np.allclose(p7, forward_tanh(m_va, P_m)[\"p\"], atol=1e-5), \"직접 계산한 확률과 다릅니다. 전치·절편을 확인하세요\"\n",
    "model7b = to_sequential(init_params(3, 4, seed=5))\n",
    "assert tuple(model7b[0].weight.shape) == (4, 3), \"d·h를 P['W1'].shape에서 읽으세요(입력 3, 은닉 4 예)\"\n",
    "X7b = np.random.default_rng(7).normal(size=(6, 3))\n",
    "assert np.allclose(predict_proba_nn(model7b, X7b), forward_tanh(X7b, init_params(3, 4, seed=5))[\"p\"], atol=1e-5), \"입력 3, 은닉 4 예에서 다릅니다\"\n",
    "print(\"매개변수 수\", sum(t.numel() for t in model7.parameters()), \"/ 검증 정확도\", round(float(np.mean((p7 >= 0.5) == ym_va)), 3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `nn.Linear`는 y = xWᵀ + b로 계산하므로 weight를 (출력, 입력)으로 저장한다. 전치를 빼먹으면 이 문제처럼 d = 2, h = 8일 때는 `copy_`가 모양 오류를 내 주지만, 정사각 행렬(d = h)이면 오류 없이 다른 모델이 된다. 그래서 모양 확인과 함께 **같은 입력에 같은 출력이 나오는지**로 검산한다. 예측 함수에서 `torch.no_grad()`는 기록을 끄고, `.numpy()`는 기록이 없으니 `detach()` 없이 된다. 모델 출력 `(N, 1)`을 `(N,)`로 줄이는 `squeeze(1)`은 정답 배열과 비교·연산하기 전에 늘 확인할 곳이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-030",
   "metadata": {},
   "source": [
    "## 문제 8. 신경망·역전파 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q8`에 적으세요.\n",
    "\n",
    "(a) 활성화 함수 없이 선형 층을 10개 쌓은 모델은 선형 층 1개와 같은 모양의 경계(직선·평면)만 만든다.\n",
    "(b) 가중치를 모두 0으로 시작해도 학습이 진행되면 은닉 유닛들이 서로 다른 특성을 배운다.\n",
    "(c) 시그모이드는 미분이 최대 0.25라서, 시그모이드 은닉층을 깊게 쌓으면 앞쪽 층의 기울기가 매우 작아지기 쉽다.\n",
    "(d) 역전파는 기울기를 계산하는 방법이고, 그 기울기로 매개변수를 고치는 것은 경사하강법(옵티마이저)이다.\n",
    "(e) 같은 구조·같은 데이터·같은 학습률이면, 신경망은 시작 난수가 달라도 늘 같은 매개변수에 도착한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q8 = \"OXOOX\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"9861f5c5fe42\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 선형식에 선형식을 넣으면 선형식이다(원고 10-5절). (b) 모두 0이면 ReLU 은닉층은 기울기 자체가 0이고, 모두 같은 값이면 유닛들이 같은 기울기를 받아 끝까지 같다(대칭, 원고 10-8절). tanh도 0에서 시작하면 H = 0이라 w₂의 기울기가 0이고, w₂ = 0이라 W₁의 기울기도 0이다. (c) 층마다 0.25 이하가 곱해진다(원고 10-11절). (d) 역전파 = 기울기 계산, 옵티마이저 = 갱신. 11장에서 `loss.backward()`와 `optimizer.step()`으로 나뉜다. (e) 신경망 손실은 볼록이 아니라 시작점에 따라 다른 곳에 멈춘다. 원고 10-8절 은닉 2개 실험에서 seed마다 결과가 달랐다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-034",
   "metadata": {},
   "source": [
    "## 문제 9. 손실이 0.693에서 멈춘 신경망 (사례)\n",
    "\n",
    "팀원이 PyTorch로 은닉 16개 MLP(은닉층 ReLU, 출력 시그모이드)를 직접 매개변수로 만들어 이진 분류를 학습했습니다. 정답 비율은 0.5입니다. 손실이 첫 스텝부터 1000 스텝까지 0.6931에서 거의 움직이지 않고, 모든 표본의 예측 확률이 0.5 근처입니다. 확인해 보니 `W1.grad`·`b1.grad`·`w2.grad`·`b2.grad`가 모두 0입니다. 매개변수는 이렇게 만들었습니다.\n",
    "\n",
    "```python\n",
    "W1 = torch.zeros(d, 16, requires_grad=True); b1 = torch.zeros(16, requires_grad=True)\n",
    "w2 = torch.zeros(16, requires_grad=True);    b2 = torch.zeros(1, requires_grad=True)\n",
    "```\n",
    "\n",
    "가장 알맞은 조치를 `q9`에 적으세요.\n",
    "\n",
    "- A. 학습률을 10배로 키운다. 기울기가 작아서 움직이지 않는 것이다.\n",
    "- B. 가중치(W1·w2)를 서로 다른 작은 난수로 초기화한다. 모두 0이면 ReLU 입력이 0이라 은닉층 기울기가 0이고, 은닉 출력도 0이라 w2의 기울기도 0이다.\n",
    "- C. 은닉 유닛을 64개로 늘린다. 모델이 너무 작아서 못 배우는 것이다.\n",
    "- D. 손실을 제곱 오차로 바꾼다. 로그 손실은 0.693 근처에서 기울기가 0이 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 0.6931 = log 2는 \"모든 표본에 0.5를 준\" 손실이다. 원고 10-8절의 \"모두 0\" 실험과 같은 상태다. 기울기가 정확히 0이므로 학습률을 키워도(A) 0 × 큰 수 = 0이고, 은닉 유닛을 늘려도(C) 모두 0이면 같은 일이 생긴다. 로그 손실의 출력 점수 기울기 p − y는 표본마다 ±0.5로 0이 아니다(D). `b2.grad` = Σ(p − y)/N이 0인 것은 정답 비율이 정확히 0.5라 +0.5와 −0.5가 상쇄됐기 때문이고(비율이 0.5가 아니면 b₂만 움직여 모든 표본에 정답 비율과 같은 확률을 내는 데서 멈춘다), `W1`·`w2`의 기울기가 0인 것은 H = 0, w₂ = 0 때문이라 손실을 제곱 오차로 바꿔도 그대로다. `nn.Linear`를 쓰면 난수 초기화가 자동이라 이런 일이 드물다. 매개변수를 직접 만들 때는 `torch.randn(d, 16) / d ** 0.5`처럼 난수로 만든 뒤 `requires_grad_()`를 붙인다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-038",
   "metadata": {},
   "source": [
    "## 문제 10. 상황별 선택 (사례)\n",
    "\n",
    "각 상황에 가장 알맞은 것을 고르세요. (a)~(e) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "- `T`: 트리 앙상블부터(07·09장)\n",
    "- `M`: 작은 MLP(ReLU 은닉층 1~2개, 입력 표준화)\n",
    "- `L`: 표준화 + 로지스틱 회귀(06장)\n",
    "- `Z`: 스텝마다 기울기를 비우는지 확인\n",
    "- `S`: 모델 출력과 정답의 모양을 맞춘다\n",
    "\n",
    "(a) 고객 이탈 예측. 표 데이터 5만 건, 숫자·범주 특성 30개. 기준선 다음에 비교할 강한 모델이 필요하다.\n",
    "(b) 공정 센서 특성 2개. 산점도를 보니 두 범주가 나선 모양으로 감겨 있고, 어떤 특성을 만들어야 할지 모르겠다.\n",
    "(c) 대출 심사 300건. 심사 결과의 이유를 특성별로 설명해야 한다.\n",
    "(d) PyTorch 학습에서 손실이 처음 몇 스텝은 줄다가 점점 크게 흔들리더니 `nan`이 됐다. 루프에는 `loss.backward()`와 갱신만 있다.\n",
    "(e) 모델 출력이 `(64, 1)`, 정답이 `(64,)`인데 직접 쓴 손실 식의 중간 텐서가 `(64, 64)`다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"TMLZS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"00667fedf1b2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-041",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 특성마다 뜻이 있는 표 데이터는 트리 앙상블이 대체로 먼저다(원고 10-12절). MLP는 그다음 비교 후보. (b) 특성이 적고 경계가 복잡하며 만들 특성을 모를 때 작은 MLP가 맞는다. 트리도 후보지만 나선처럼 매끄럽게 휜 경계는 계단 모양으로만 근사한다. (c) 데이터가 적고 설명이 필요하면 계수로 설명하는 로지스틱 회귀. (d) 기울기를 비우지 않으면 지난 기울기가 쌓여 갱신 폭이 커지고 결국 발산한다(원고 10-9절). 학습률이 너무 커도 비슷해 보이므로, 먼저 비우기 줄을 확인하고 그다음 학습률을 본다. (e) `(64, 1) − (64,)`이 브로드캐스팅된 것이다(원고 10-10절). 출력을 `squeeze(1)` 하거나 정답을 `(64, 1)`로 바꾼다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-042",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 5에서 `1 - H ** 2`를 `(c[\"A\"] > 0)`으로 바꿔 수치 미분 점검이 실패하는 것을 확인했다(활성화 함수와 미분은 짝이 맞아야 한다).\n",
    "- [ ] 문제 6에서 은닉 유닛을 2개로, seed를 바꿔 가며 검증 정확도가 어떻게 달라지는지 봤다.\n",
    "- [ ] 문제 6의 `train_ref`에서 `t.grad.zero_()`를 지우면 손실이 어떻게 되는지 확인했다.\n",
    "- [ ] 원고 10-13절 선택 기준표의 다섯 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(11장)에서는 이 학습 루프를 `Dataset`·`DataLoader`·옵티마이저로 정리하고, 미니배치·에폭·학습 곡선을 다룬다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
