{
 "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 = None"
   ]
  },
  {
   "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": [
    "## 문제 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-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def to_tensors(X, y):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-007",
   "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-008",
   "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-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def act_grads(z):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-010",
   "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-011",
   "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-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def forward_tanh(X, P):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-013",
   "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-014",
   "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-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def backward_tanh(X, y, P, c):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-016",
   "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-017",
   "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-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def train_tanh(X, y, P, lr=0.5, steps=2000):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-019",
   "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-020",
   "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-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def to_sequential(P):\n",
    "    pass   # 작성\n",
    "\n",
    "def predict_proba_nn(model, X):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-022",
   "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-023",
   "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-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q8 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"9861f5c5fe42\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-026",
   "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-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-029",
   "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-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch10-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"00667fedf1b2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch10-032",
   "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
}
