{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch04-000",
   "metadata": {},
   "source": [
    "# 04장 실습. 학습이란: 선형 회귀를 직접\n",
    "\n",
    "**목표:** 선형 회귀의 예측·손실·그래디언트·경사하강법을 NumPy로 직접 쓰고, scikit-learn·최소제곱 결과와 같은지 확인한다. 학습률과 특성 스케일이 학습에 주는 영향을 실험으로 본다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 배열을 바꾸지 않고** 새 값을 돌려준다.\n",
    "- 문제 6은 문제 5의 `fit_gd`를 쓴다. 순서대로 푼다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.datasets import load_diabetes\n",
    "from sklearn.linear_model import LinearRegression\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",
    "# 가상의 광고 데이터: 가게 200곳의 광고비 2종(백만 원)과 매출(백만 원)\n",
    "rng = np.random.default_rng(1)\n",
    "n = 200\n",
    "ads = np.column_stack([rng.uniform(0, 10, n), rng.uniform(0, 5, n)]).round(2)   # (200, 2): 전단지, 온라인\n",
    "sales = (3 * ads[:, 0] + 5 * ads[:, 1] + 20 + rng.normal(0, 3, n)).round(1)     # (200,)\n",
    "\n",
    "# 당뇨병 데이터(03장): 특성 10개, 단위가 제각각\n",
    "dia = load_diabetes(scaled=False)\n",
    "Xd_tr, Xd_te, yd_tr, yd_te = train_test_split(dia.data, dia.target, test_size=0.2, random_state=0)\n",
    "\n",
    "print(\"ads\", ads.shape, \"sales\", sales.shape, \"/ 당뇨병 훈련\", Xd_tr.shape, \"테스트\", Xd_te.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-002",
   "metadata": {},
   "source": [
    "## 문제 1. X·y의 shape와 과제 종류 (개념)\n",
    "\n",
    "집 500채의 특성 8개(면적, 방 수, 연식 …)로 표를 만들었습니다. 아래를 (a)~(f) 순서대로 리스트 `q1`에 적으세요. shape는 튜플로, 과제 종류는 회귀면 `\"R\"`, 분류면 `\"C\"`로 적습니다.\n",
    "\n",
    "(a) 특성 배열 `X`의 shape\n",
    "(b) 집값 정답 `y`의 shape\n",
    "(c) 집값(원)을 맞히는 과제\n",
    "(d) 같은 `X`로 \"다음 달 안에 팔릴까(예/아니오)\"를 맞히는 과제\n",
    "(e) 같은 `X`로 집의 에너지 등급(1·2·3등급)을 맞히는 과제\n",
    "(f) (c)를 선형 회귀로 풀 때 가중치 `w`의 shape\n",
    "\n",
    "예: `q1 = [(1, 2), (3,), \"R\", \"R\", \"R\", (4,)]`\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "행 = 표본, 열 = 특성. 정답은 표본마다 하나. 회귀·분류는 `y`가 숫자 크기에 뜻이 있는 값인지, 범주인지로 가릅니다. 숫자로 적힌 등급(1·2·3)도 범주입니다. `w`는 특성마다 하나입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q1 = [(500, 8), (500,), 'R', 'C', 'C', (8,)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"5a76e58d16ac\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-005",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 표본 500 × 특성 8 → `(500, 8)`. (b) 정답은 표본마다 하나 → `(500,)`. (c) 금액은 크기에 뜻이 있는 숫자 → 회귀. (d) 예/아니오 → 분류. (e) 1·2·3으로 적혀 있어도 정해진 범주 중 하나를 고르는 것이므로 분류다(등급 사이의 순서를 쓰는 방법도 있지만 여기서는 과제 종류만 묻는다). (f) 가중치는 특성마다 하나 → `(8,)`. `X @ w`가 `(500, 8) @ (8,) → (500,)`으로 정답과 같은 shape가 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-006",
   "metadata": {},
   "source": [
    "## 문제 2. 예측과 손실 (코드)\n",
    "\n",
    "1. `predict(X, w, b)`: `X @ w + b`. shape `(N,)`을 돌려줍니다.\n",
    "2. `mse(y, y_hat)`: 평균제곱오차(숫자 하나). 단, `y`와 `y_hat`의 **shape가 다르면** `ValueError`를 냅니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`if y.shape != y_hat.shape: raise ValueError(...)`. `(N,)`과 `(N, 1)`을 빼면 브로드캐스팅으로 `(N, N)`이 되어 오류 없이 틀린 손실이 나오므로 미리 막습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def predict(X, w, b):\n",
    "    return X @ w + b\n",
    "\n",
    "def mse(y, y_hat):\n",
    "    if y.shape != y_hat.shape:\n",
    "        raise ValueError(f\"shape가 다릅니다: {y.shape} vs {y_hat.shape}\")\n",
    "    return np.mean((y_hat - y) ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-008",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "Xs = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])\n",
    "p = predict(Xs, np.array([0.5, -1.0]), 2.0)\n",
    "assert p is not None, \"predict: 결과를 return 하세요\"\n",
    "assert p.shape == (3,) and np.allclose(p, [0.5, -0.5, -1.5]), f\"predict 결과가 {p}입니다\"\n",
    "ys = np.array([1.0, 0.0, -1.0])\n",
    "m = mse(ys, p)\n",
    "assert m is not None, \"mse: 결과를 return 하세요\"\n",
    "assert np.isclose(m, (0.25 + 0.25 + 0.25) / 3), f\"mse가 {m}입니다\"\n",
    "try:\n",
    "    mse(ys.reshape(-1, 1), p)\n",
    "    raise AssertionError(\"y가 (N, 1)이고 y_hat이 (N,)인데 ValueError가 나지 않았습니다\")\n",
    "except ValueError:\n",
    "    pass\n",
    "base = mse(sales, predict(ads, np.zeros(2), sales.mean()))\n",
    "print(\"늘 평균으로 예측할 때 MSE\", round(float(base), 2), \"= 매출 분산\", round(float(sales.var()), 2))\n",
    "assert np.isclose(base, sales.var())\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `predict`는 행렬곱 한 번이다. `mse`는 잔차 제곱의 평균인데, `y`가 `(N, 1)`로 들어오면 `(N,)`과의 뺄셈이 `(N, N)`으로 퍼져 전혀 다른 값을 낸다. 손실 함수 첫 줄에서 shape를 확인하면 이런 실수가 조용히 지나가지 않는다. 점검 끝의 예처럼 \"늘 평균으로 예측\"한 MSE는 `y`의 분산(ddof=0)과 같다. 모델의 MSE가 이보다 작아야 의미가 있다(R²가 0보다 큰 것과 같은 말, 5장)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-010",
   "metadata": {},
   "source": [
    "## 문제 3. MSE의 그래디언트 (코드)\n",
    "\n",
    "`gradient(X, y, w, b)`를 쓰세요. `(dw, db)`를 돌려줍니다.\n",
    "\n",
    "- dw = (2/N) Xᵀ(ŷ − y), shape `(d,)`\n",
    "- db = (2/N) Σ(ŷᵢ − yᵢ), 숫자 하나\n",
    "\n",
    "점검 셀은 무작위 데이터에서 **수치 미분**과 비교합니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`err = predict(X, w, b) - y`를 먼저 만들고, `X.T @ err`와 `err.sum()`을 씁니다. `N = len(y)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def gradient(X, y, w, b):\n",
    "    err = predict(X, w, b) - y\n",
    "    return 2 / len(y) * (X.T @ err), 2 / len(y) * err.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "r = np.random.default_rng(7)\n",
    "Xr, yr = r.normal(size=(20, 3)), r.normal(size=20)\n",
    "wr, br = r.normal(size=3), 0.3\n",
    "Xr0, yr0, wr0 = Xr.copy(), yr.copy(), wr.copy()\n",
    "res = gradient(Xr, yr, wr, br)\n",
    "assert res is not None, \"결과를 return 하세요\"\n",
    "dw, db = res\n",
    "assert np.array_equal(Xr, Xr0) and np.array_equal(yr, yr0) and np.array_equal(wr, wr0), \"입력 배열이 바뀌었습니다\"\n",
    "assert np.shape(dw) == (3,), f\"dw shape가 {np.shape(dw)}입니다. w와 같은 (d,)여야 합니다\"\n",
    "eps = 1e-6\n",
    "num_dw = np.array([(mse(yr, predict(Xr, wr + eps * e, br)) - mse(yr, predict(Xr, wr - eps * e, br))) / (2 * eps)\n",
    "                   for e in np.eye(3)])\n",
    "num_db = (mse(yr, predict(Xr, wr, br + eps)) - mse(yr, predict(Xr, wr, br - eps))) / (2 * eps)\n",
    "assert np.allclose(dw, num_dw, atol=1e-5), f\"dw {np.round(dw, 4)} ≠ 수치 미분 {np.round(num_dw, 4)}\"\n",
    "assert np.isclose(db, num_db, atol=1e-5), f\"db {db:.4f} ≠ 수치 미분 {num_db:.4f}\"\n",
    "print(\"dw\", np.round(dw, 4), \"수치\", np.round(num_dw, 4))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 잔차를 한 번 만들고 `Xᵀ @ 잔차`로 특성마다 \"특성 값 × 잔차\"의 합을 구한다. 2/N은 MSE의 평균과 제곱을 미분한 결과다. 직접 쓴 그래디언트는 작은 무작위 데이터에서 수치 미분과 비교해 검산한다. 부호를 틀리거나(ŷ − y 대신 y − ŷ) 2/N을 빼먹으면 여기서 바로 드러난다. 2/N을 빼먹어도 방향은 같아 학습은 되지만, 같은 학습률의 뜻이 데이터 크기마다 달라진다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-014",
   "metadata": {},
   "source": [
    "## 문제 4. 학습률·스텝·스케일 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q4`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) 학습률을 10배 키우면 수렴도 언제나 10배 빨라진다.\n",
    "(b) 손실이 스텝마다 커지면 먼저 학습률을 줄여 본다.\n",
    "(c) 표준화의 평균·표준편차는 훈련·테스트를 합친 데이터에서 구해야 더 정확하다.\n",
    "(d) `LinearRegression`은 학습률을 정해 주지 않아도 된다.\n",
    "(e) 그래디언트가 0인 점에서는 경사하강법의 갱신이 멈춘다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q4 = \"XOXOO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q4\", q4, \"82d8e70f5137\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 어느 선을 넘으면 바닥을 지나쳐 발산한다(원고 4-7절의 0.03). (b) 손실 증가는 학습률이 너무 클 때의 전형적인 모습이다. (c) 테스트 정보가 훈련에 섞이는 누수다. 훈련 데이터로만 `fit`하고 같은 값으로 테스트를 변환한다(03장 결측 대체와 같은 규칙). (d) 최소제곱으로 한 번에 풀므로 학습률·스텝이 없다. (e) 갱신량이 학습률 × 그래디언트이므로 0이면 움직이지 않는다. 선형 회귀의 MSE는 그래디언트가 0인 곳이 최솟값이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-018",
   "metadata": {},
   "source": [
    "## 문제 5. 경사하강법 (코드)\n",
    "\n",
    "`fit_gd(X, y, lr, steps)`를 쓰세요. `(w, b, history)`를 돌려줍니다.\n",
    "\n",
    "- `w`는 0 벡터, `b`는 0에서 출발합니다.\n",
    "- 스텝마다 **갱신 전 손실**을 `history`(파이썬 리스트)에 적고, `w ← w − lr·dw`, `b ← b − lr·db`로 갱신합니다. `len(history) == steps`.\n",
    "- 입력 배열을 바꾸지 않습니다.\n",
    "\n",
    "점검 셀은 광고 데이터를 학습률 0.01로 5000스텝 학습해 `LinearRegression`과 비교하고 손실 곡선을 그립니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 4-6절. `w = np.zeros(X.shape[1])`. 반복마다 `history.append(float(mse(y, predict(X, w, b))))` → `dw, db = gradient(...)` → 갱신.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def fit_gd(X, y, lr, steps):\n",
    "    w, b, history = np.zeros(X.shape[1]), 0.0, []\n",
    "    for _ in range(steps):\n",
    "        history.append(float(mse(y, predict(X, w, b))))\n",
    "        dw, db = gradient(X, y, w, b)\n",
    "        w, b = w - lr * dw, b - lr * db\n",
    "    return w, b, history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-020",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "Xt, yt = np.array([[1.0, 2.0], [3.0, -1.0], [0.0, 1.0]]), np.array([1.0, 2.0, -1.0])\n",
    "res = fit_gd(Xt, yt, lr=0.1, steps=3)\n",
    "assert res is not None, \"결과를 return 하세요\"\n",
    "wt, bt, ht = res\n",
    "assert isinstance(ht, list), f\"history는 파이썬 리스트여야 합니다(지금 {type(ht).__name__})\"\n",
    "w_ref, b_ref, h_ref = np.zeros(2), 0.0, []\n",
    "for _ in range(3):                                              # 독립 계산: 갱신 전 손실 → 갱신\n",
    "    e = Xt @ w_ref + b_ref - yt\n",
    "    h_ref.append(np.mean(e ** 2))\n",
    "    w_ref, b_ref = w_ref - 0.1 * 2 / 3 * (Xt.T @ e), b_ref - 0.1 * 2 / 3 * e.sum()\n",
    "assert np.allclose(ht, h_ref), f\"history {np.round(ht, 4)} ≠ 기대 {np.round(h_ref, 4)}. 스텝마다 갱신 전 손실을 적으세요\"\n",
    "assert np.allclose(wt, w_ref) and np.isclose(bt, b_ref), \"3스텝 뒤 w·b가 기대값과 다릅니다\"\n",
    "ads0, sales0 = ads.copy(), sales.copy()\n",
    "w5, b5, h5 = fit_gd(ads, sales, lr=0.01, steps=5000)\n",
    "assert np.array_equal(ads, ads0) and np.array_equal(sales, sales0), \"입력 배열이 바뀌었습니다\"\n",
    "assert len(h5) == 5000, f\"history 길이가 {len(h5)}입니다. 스텝마다 하나씩\"\n",
    "assert np.isclose(h5[0], np.mean(sales ** 2)), \"history[0]은 w = 0, b = 0일 때(갱신 전) 손실이어야 합니다\"\n",
    "assert all(a >= c for a, c in zip(h5, h5[1:])), \"이 학습률에서는 손실이 줄기만 해야 합니다. 갱신 방향(부호)을 확인하세요\"\n",
    "lin = LinearRegression().fit(ads, sales)\n",
    "assert np.allclose(w5, lin.coef_, atol=1e-3) and np.isclose(b5, lin.intercept_, atol=1e-3), \\\n",
    "    f\"w={np.round(w5, 3)}, b={b5:.3f} / LinearRegression w={np.round(lin.coef_, 3)}, b={lin.intercept_:.3f}\"\n",
    "print(\"경사하강법\", np.round(w5, 3), round(b5, 3), \"/ LinearRegression\", np.round(lin.coef_, 3), round(lin.intercept_, 3))\n",
    "fig, ax = plt.subplots(figsize=(5, 3))\n",
    "ax.plot(h5); ax.set_yscale(\"log\"); ax.set_xlabel(\"스텝\"); ax.set_ylabel(\"MSE\"); ax.set_title(\"손실 곡선\")\n",
    "plt.show()\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 갱신 전 손실을 적어 두면 `history[0]`이 출발점의 손실이 되어 곡선을 읽기 쉽다. `w = w - lr * dw`처럼 새 배열을 만들면 입력이나 바깥 변수를 건드릴 일이 없다. 5000스텝 뒤에는 `LinearRegression`의 최소제곱 해와 소수 셋째 자리까지 같다. 참값(3, 5, 20)과 조금 다른 것은 잡음 때문이고, 두 방법이 찾는 것은 \"이 데이터에서 손실이 가장 작은 직선\"으로 같다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-022",
   "metadata": {},
   "source": [
    "## 문제 6. 학습률 실험 (코드)\n",
    "\n",
    "1. `lr_scan(X, y, lrs, steps)`: 학습률마다 `fit_gd`로 학습해 `{학습률: 마지막 손실 history[-1]}` 딕셔너리를 돌려줍니다. 발산해서 `inf`·`nan`이 나와도 그대로 담습니다(경고는 `np.errstate`로 숨겨도 됩니다).\n",
    "2. `best_lr(results)`: `lr_scan` 결과에서 손실이 **유한하면서** 가장 작은 학습률을 돌려줍니다. 유한한 값이 하나도 없으면 `None`.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`with np.errstate(over=\"ignore\", invalid=\"ignore\"):` 안에서 학습합니다. 유한한지는 `np.isfinite(v)`. `nan`은 어떤 비교도 거짓이라 `min`에 그대로 넣으면 엉뚱한 답이 나올 수 있습니다. 유한한 것만 먼저 고르세요.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def lr_scan(X, y, lrs, steps):\n",
    "    out = {}\n",
    "    with np.errstate(over=\"ignore\", invalid=\"ignore\"):\n",
    "        for lr in lrs:\n",
    "            out[lr] = fit_gd(X, y, lr, steps)[2][-1]\n",
    "    return out\n",
    "\n",
    "def best_lr(results):\n",
    "    finite = {lr: v for lr, v in results.items() if np.isfinite(v)}\n",
    "    return min(finite, key=finite.get) if finite else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "lrs = [0.0001, 0.001, 0.01, 0.03]\n",
    "scan = lr_scan(ads, sales, lrs, 2000)\n",
    "assert scan is not None, \"lr_scan: 결과를 return 하세요\"\n",
    "assert list(scan) == lrs, f\"키가 {list(scan)}입니다\"\n",
    "with np.errstate(over=\"ignore\", invalid=\"ignore\"):\n",
    "    for lr in lrs:\n",
    "        ref = fit_gd(ads, sales, lr, 2000)[2][-1]\n",
    "        got = scan[lr]\n",
    "        if np.isnan(ref):\n",
    "            ok = np.isnan(got)\n",
    "        elif np.isinf(ref):\n",
    "            ok = got == ref                                     # 같은 부호의 무한대\n",
    "        else:\n",
    "            ok = np.isfinite(got) and np.isclose(got, ref)\n",
    "        assert ok, f\"학습률 {lr} 결과가 {got}입니다. 기대 {ref} (inf·nan도 바꾸지 말고 그대로 담으세요)\"\n",
    "for lr, v in scan.items():\n",
    "    print(lr, f\"{v:.4g}\")\n",
    "assert best_lr({0.1: np.nan, 0.2: 5.0, 0.3: np.inf, 0.4: 7.0}) == 0.2, \"nan·inf를 빼고 골라야 합니다\"\n",
    "assert best_lr({0.1: np.inf, 0.2: np.nan}) is None, \"모두 발산했으면 None이어야 합니다(inf도 빼야 합니다)\"\n",
    "b_lr = best_lr(scan)\n",
    "assert b_lr == 0.01, f\"best_lr이 {b_lr}입니다\"\n",
    "print(\"가장 좋은 학습률\", b_lr)\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 0.0001·0.001은 2000스텝 안에 바닥까지 못 가서 손실이 크고, 0.03은 발산해 `inf`가 된다. 0.01이 가장 작다. 실제로는 10배 간격으로 몇 개 돌려 보고 그 근처를 더 촘촘히 본다. `nan`은 `<`·`>` 비교가 모두 거짓이라, 딕셔너리 첫 값이 `nan`이면 `min(results, key=results.get)`이 `nan`인 학습률을 돌려줄 수 있다. 점검 셀의 작은 예가 이 함정을 본다. 유한한 값만 먼저 고르는 것이 안전하다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-026",
   "metadata": {},
   "source": [
    "## 문제 7. 표준화하고 학습, 원래 단위로 되돌리기 (코드)\n",
    "\n",
    "`fit_standardized(X_tr, y_tr, lr, steps)`를 쓰세요. `(w, b, mean, std)`를 돌려줍니다.\n",
    "\n",
    "- `mean`, `std`: `X_tr`의 열별 평균·표준편차(`ddof=0`, `StandardScaler`와 같음).\n",
    "- `Z = (X_tr − mean) / std`로 `fit_gd`를 돌린 뒤, 결과를 **원래 단위의 가중치·절편**으로 바꿔 돌려줍니다. 즉 `X_te @ w + b`가 표준화 없이 바로 예측이 되게 합니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "표준화 모델의 예측 ŷ = Σⱼ wzⱼ (xⱼ − μⱼ)/σⱼ + bz 를 xⱼ에 대해 정리하면 wⱼ = wzⱼ/σⱼ, b = bz − Σⱼ wzⱼ μⱼ/σⱼ 입니다. 코드로는 `w = wz / std`, `b = bz - (wz * mean / std).sum()`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def fit_standardized(X_tr, y_tr, lr, steps):\n",
    "    mean, std = X_tr.mean(axis=0), X_tr.std(axis=0)\n",
    "    wz, bz, _ = fit_gd((X_tr - mean) / std, y_tr, lr, steps)\n",
    "    return wz / std, bz - (wz * mean / std).sum(), mean, std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "X0 = Xd_tr.copy()\n",
    "res = fit_standardized(Xd_tr, yd_tr, lr=0.1, steps=5000)\n",
    "assert res is not None, \"결과를 return 하세요\"\n",
    "w7, b7, mu7, sd7 = res\n",
    "assert np.array_equal(Xd_tr, X0), \"입력 배열이 바뀌었습니다\"\n",
    "assert np.allclose(mu7, Xd_tr.mean(axis=0)) and np.allclose(sd7, Xd_tr.std(axis=0)), \"mean·std는 X_tr의 열별 값(ddof=0)이어야 합니다\"\n",
    "lin7 = LinearRegression().fit(Xd_tr, yd_tr)                    # 표준화 없이 원래 단위로\n",
    "p_gd, p_lin = Xd_te @ w7 + b7, lin7.predict(Xd_te)\n",
    "assert np.allclose(w7, lin7.coef_, rtol=1e-2, atol=1e-2), f\"원래 단위 계수가 다릅니다\\n{np.round(w7, 3)}\\n{np.round(lin7.coef_, 3)}\"\n",
    "assert np.allclose(p_gd, p_lin, atol=0.1), f\"테스트 예측 차이 최대 {np.abs(p_gd - p_lin).max():.3f}. 절편 변환을 확인하세요\"\n",
    "print(\"원래 단위 계수\", np.round(w7, 3))\n",
    "print(\"테스트 예측 최대 차이\", round(float(np.abs(p_gd - p_lin).max()), 4))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 표준화하면 학습률 0.1로도 안정적으로 수렴한다(원래 단위로는 0.01에서도 발산, 원고 4-7절). 표준화는 선형 변환이므로 학습한 가중치를 원래 단위로 되돌릴 수 있고, 결과는 표준화 없이 `LinearRegression`을 맞춘 것과 같다. 최소제곱 해는 스케일에 따라 계수의 단위만 바뀔 뿐 예측은 그대로이기 때문이다. 평균·표준편차는 훈련 데이터에서만 구했고, 테스트는 그 값이 들어간 `w`·`b`로 예측한다. 실무에서는 이렇게 손으로 되돌리기보다 `StandardScaler`와 모델을 `Pipeline`으로 묶는다(9장)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-030",
   "metadata": {},
   "source": [
    "## 문제 8. 최소제곱 해 (코드)\n",
    "\n",
    "`least_squares(X, y)`를 `np.linalg.lstsq`로 쓰세요. `(w, b)`를 돌려줍니다. `X` 앞에 1로 된 열을 붙여 절편을 함께 구합니다. sklearn은 쓰지 않습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`X1 = np.column_stack([np.ones(len(X)), X])`, `theta, *_ = np.linalg.lstsq(X1, y, rcond=None)`. `theta[0]`이 절편, `theta[1:]`이 가중치입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def least_squares(X, y):\n",
    "    X1 = np.column_stack([np.ones(len(X)), X])\n",
    "    theta, *_ = np.linalg.lstsq(X1, y, rcond=None)\n",
    "    return theta[1:], theta[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "for Xa, ya, name in [(ads, sales, \"광고\"), (Xd_tr, yd_tr, \"당뇨병\")]:\n",
    "    res = least_squares(Xa, ya)\n",
    "    assert res is not None, \"결과를 return 하세요\"\n",
    "    w8, b8 = res\n",
    "    ref = LinearRegression().fit(Xa, ya)\n",
    "    assert np.shape(w8) == (Xa.shape[1],), f\"{name}: w shape가 {np.shape(w8)}입니다\"\n",
    "    assert np.allclose(w8, ref.coef_, atol=1e-6) and np.isclose(b8, ref.intercept_, atol=1e-6), f\"{name}: 결과가 LinearRegression과 다릅니다. 절편 열을 붙였나요?\"\n",
    "    print(name, np.round(w8, 3)[:4], round(float(b8), 3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 절편을 1로 된 열의 가중치로 보면 `w`와 `b`를 한 번에 구할 수 있다. 1 열을 빼먹으면 직선이 원점을 지나도록 강제되어 결과가 달라진다. `lstsq`는 반복·학습률 없이 MSE가 가장 작은 해를 바로 주고, 당뇨병 데이터처럼 단위가 제각각이어도 표준화가 필요 없다. 정규방정식을 `np.linalg.inv(X1.T @ X1) @ X1.T @ y`로 직접 풀 수도 있지만, 특성끼리 상관이 높으면 수치가 불안정해지므로 `lstsq`를 쓴다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-034",
   "metadata": {},
   "source": [
    "## 문제 9. 손실이 nan이 됐다 (사례)\n",
    "\n",
    "동료가 집값 예측을 경사하강법으로 직접 짰습니다. 특성은 면적(㎡, 30~250), 방 수(1~6), 연식(년, 0~40)이고 정답은 가격(원, 1억~20억)입니다. 학습률 0.01로 돌리자 손실이 몇 스텝 만에 10⁴⁰ 이상으로 치솟았고, 계속 돌리자 `inf`, 이어서 `nan`이 됐습니다. 가장 알맞은 진단과 조치를 `q9`에 적으세요.\n",
    "\n",
    "- A. 표본이 너무 적다. 데이터를 더 모은다.\n",
    "- B. 특성·정답 값이 커서 그래디언트가 크고, 이 스케일에서는 학습률이 너무 크다. 특성을 훈련 데이터 기준으로 표준화하고(정답 단위를 억 원으로 바꾸는 것도 도움), 학습률을 10배씩 줄여 손실 곡선을 확인한다.\n",
    "- C. 스텝 수가 부족하다. 스텝을 10배 늘린다.\n",
    "- D. `w`를 0에서 출발했기 때문이다. 무작위 값에서 출발한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 손실이 줄지 않고 몇 스텝 만에 폭발하는 것은 한 걸음이 너무 큰 발산의 모습이다. 그래디언트는 특성 값과 잔차에 비례하므로, 값이 수백(면적)이고 잔차가 수억 원이면 그래디언트가 엄청나게 커진다. 표준화로 특성 스케일을 맞추고 학습률을 줄이면 해결된다. 데이터를 늘려도(A) 스케일이 그대로라 발산은 막지 못하고, 스텝을 늘리면(C) 발산이 더 진행될 뿐이다. 선형 회귀의 MSE는 그릇 모양이라 출발점과 상관없이 같은 바닥으로 가고, 학습률이 크면 어디서 출발해도 발산한다(D 오답). 선형 회귀라면 애초에 `LinearRegression`(최소제곱)을 쓰면 학습률 문제가 없다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-038",
   "metadata": {},
   "source": [
    "## 문제 10. 최소제곱과 경사하강법 (사례)\n",
    "\n",
    "각 상황에서 최소제곱(`LinearRegression`, 한 번에 풀기)이 알맞으면 `L`, 경사하강법이 필요하면 `G`. (a)~(d) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "(a) 특성 20개, 표본 5000개로 집값을 선형 회귀(손실 MSE)로 예측한다.\n",
    "(b) 합격 확률을 내는 로지스틱 회귀를 학습한다. 손실(교차 엔트로피)을 최소로 하는 해를 식으로 바로 풀 수 없다(6장).\n",
    "(c) 사진을 입력으로 받는 신경망을 학습한다.\n",
    "(d) 표본 2000개의 선형 회귀(손실 MSE)인데, 학습률·스텝을 고를 시간이 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"LGGL\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"b9f6a4c335aa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-041",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a)(d) 손실이 MSE인 선형 회귀이고 데이터가 메모리에 들어가는 크기라 최소제곱으로 한 번에 푼다. 하이퍼파라미터가 없어 고를 것도 없다. (b) 로지스틱 회귀는 닫힌 해가 없어 반복 최적화(경사하강법 계열)로 푼다. sklearn `LogisticRegression`도 안에서 반복 최적화를 쓰고 `max_iter`가 있다. (c) 신경망은 매개변수가 많고 닫힌 해가 없다. 미니배치 경사하강법(11장)이 기본이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-042",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 3의 `gradient`에서 부호를 바꿔(y − ŷ) 문제 5의 손실 곡선이 어떻게 되는지 확인했다.\n",
    "- [ ] 문제 7을 표준화 없이 `fit_gd(Xd_tr, yd_tr, 0.1, 100)`으로 돌려 손실이 어떻게 되는지 확인했다.\n",
    "- [ ] 원고 4-9절 선택 기준표의 네 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(05장)에서는 이렇게 학습한 모델이 **처음 보는 데이터**에서도 잘 맞는지 재는 방법(훈련·검증·테스트, 과적합, 지표)을 다룬다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
