{
 "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 = None"
   ]
  },
  {
   "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": [
    "## 문제 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-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def predict(X, w, b):\n",
    "    pass   # 작성\n",
    "\n",
    "def mse(y, y_hat):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-007",
   "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-008",
   "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-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def gradient(X, y, w, b):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-010",
   "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-011",
   "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-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q4 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q4\", q4, \"82d8e70f5137\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-014",
   "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-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def fit_gd(X, y, lr, steps):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-016",
   "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-017",
   "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-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def lr_scan(X, y, lrs, steps):\n",
    "    pass   # 작성\n",
    "\n",
    "def best_lr(results):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-019",
   "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-020",
   "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-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def fit_standardized(X_tr, y_tr, lr, steps):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-022",
   "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-023",
   "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-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def least_squares(X, y):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-025",
   "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-026",
   "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-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-029",
   "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-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch04-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"b9f6a4c335aa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch04-032",
   "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
}
