{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch08-000",
   "metadata": {},
   "source": [
    "# 08장 실습. 거리와 비지도 학습\n",
    "\n",
    "**목표:** 모든 쌍의 거리, kNN, k-평균, 코사인 유사도 검색을 NumPy로 직접 구현해 sklearn과 맞추고, PCA로 차원을 줄이고 복원한다. 표준화와 k를 교차검증으로 고르고, 군집·차원 축소 결과를 상황에 맞게 판단한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 배열을 바꾸지 않고** 새 값을 돌려준다.\n",
    "- 문제 3·5는 문제 2의 `sq_dists`를 쓴다. 순서대로 푼다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안팎에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.datasets import make_blobs, load_digits\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.neighbors import KNeighborsClassifier, NearestNeighbors\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.metrics.pairwise import euclidean_distances\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",
    "# 가상의 과일 선별 데이터: 600개, 특품(1) 여부. 무게는 규칙에 거의 없지만 단위(g)가 커서 거리를 독차지한다\n",
    "rng = np.random.default_rng(8)\n",
    "n = 600\n",
    "fruit_names = [\"무게g\", \"당도\", \"지름cm\", \"산도\"]\n",
    "F = np.column_stack([\n",
    "    rng.normal(200, 50, n),              # 무게(g)\n",
    "    rng.normal(12, 1.5, n),              # 당도(Brix)\n",
    "    rng.normal(8, 0.8, n),               # 지름(cm)\n",
    "    rng.normal(0.6, 0.1, n),             # 산도(%)\n",
    "])\n",
    "yf = ((F[:, 1] - 12) / 1.5 + (F[:, 2] - 8) / 0.8 - (F[:, 3] - 0.6) / 0.1 + rng.normal(0, 0.7, n) > 0.5).astype(int)\n",
    "f_tr, f_va, yf_tr, yf_va = train_test_split(F, yf, test_size=0.3, stratify=yf, random_state=0)\n",
    "\n",
    "# 군집용 가상 데이터(문제 5): 덩어리 3개\n",
    "Xk, yk = make_blobs(n_samples=300, centers=3, cluster_std=1.2, random_state=3)\n",
    "\n",
    "# 손글씨 숫자(문제 6·7): 8×8 = 64차원\n",
    "digits = load_digits()\n",
    "g_tr, g_va, yg_tr, yg_va = train_test_split(digits.data, digits.target, test_size=0.3, stratify=digits.target, random_state=0)\n",
    "\n",
    "print(\"과일 훈련\", f_tr.shape, \"검증\", f_va.shape, \"/ 특품 비율\", round(yf.mean(), 3))\n",
    "print(\"특성별 표준편차\", dict(zip(fruit_names, F.std(axis=0).round(2))))\n",
    "print(\"군집\", Xk.shape, \"/ 손글씨 훈련\", g_tr.shape, \"검증\", g_va.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-002",
   "metadata": {},
   "source": [
    "## 문제 1. 거리·kNN 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q1`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) 특성 하나의 단위를 cm에서 m로 바꾸면 유클리드 거리로 찾은 가장 가까운 이웃이 바뀔 수 있다.\n",
    "(b) kNN은 학습 단계에서 경사하강법으로 가중치를 찾고, 예측은 그 가중치로 한다.\n",
    "(c) 같은 좌표에 정답이 다른 표본이 없다면, k = 1 kNN의 훈련 정확도는 1.0이다.\n",
    "(d) 서로 독립인 무작위 특성을 늘려 차원이 커질수록, 한 점에서 가장 가까운 점과 가장 먼 점의 거리 비율(최근접/최원)은 0에 가까워진다.\n",
    "(e) 길이를 1로 정규화한 두 벡터의 코사인 유사도는 두 벡터의 내적과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q1 = \"OXOXO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"4be14a469932\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-005",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 다른 특성과의 상대적 무게가 바뀌므로 이웃이 바뀔 수 있다(원고 8-3절). 모든 특성의 단위를 똑같이 바꾸면 거리가 같은 비율로 변해 이웃은 그대로다. (b) kNN은 훈련 데이터를 저장할 뿐이고, 예측할 때 거리를 잰다. (c) 훈련 표본의 가장 가까운 이웃은 거리 0인 자기 자신이다. (d) 반대로 1에 가까워진다. 모든 점이 비슷하게 멀어지는 것이 차원의 저주다. 실제 데이터에서는 정답과 무관한 독립적인 특성이 많을수록 이런 일이 심해진다. (e) cos = a·b / (‖a‖‖b‖)에서 분모가 1이다(원고 8-7절)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-006",
   "metadata": {},
   "source": [
    "## 문제 2. 모든 쌍의 거리² (코드)\n",
    "\n",
    "`sq_dists(A, B)`를 쓰세요. (m, d) 배열 `A`와 (n, d) 배열 `B`를 받아 `[i, j]`가 ‖A[i] − B[j]‖²인 (m, n) 배열을 돌려줍니다.\n",
    "\n",
    "- 이중 for 문 없이 ‖a‖² + ‖b‖² − 2 a·b 전개와 행렬곱을 씁니다.\n",
    "- 반올림 오차로 생기는 아주 작은 음수는 0으로 바꿉니다(거리²는 음수가 아닙니다).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`(A ** 2).sum(axis=1)[:, None]`는 (m, 1), `(B ** 2).sum(axis=1)[None, :]`는 (1, n), `A @ B.T`는 (m, n)입니다. 마지막에 `np.maximum(D2, 0)`. 원고 8-3절 수학 상자와 같습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def sq_dists(A, B):\n",
    "    D2 = (A ** 2).sum(axis=1)[:, None] + (B ** 2).sum(axis=1)[None, :] - 2 * A @ B.T\n",
    "    return np.maximum(D2, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-008",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "A2 = np.array([[0.0, 0.0], [1.0, 1.0]])\n",
    "B2 = np.array([[3.0, 4.0], [1.0, 0.0], [0.0, 0.0]])\n",
    "r2 = sq_dists(A2, B2)\n",
    "assert r2 is not None, \"결과를 return 하세요\"\n",
    "assert np.shape(r2) == (2, 3), f\"모양이 {np.shape(r2)}입니다. (len(A), len(B))여야 합니다\"\n",
    "assert np.allclose(r2, [[25, 1, 0], [13, 1, 2]]), f\"작은 예에서 {r2.tolist()}입니다\"\n",
    "FA, FB = f_tr[:7].copy(), f_tr[7:12].copy()\n",
    "loop = np.array([[np.sum((p - q) ** 2) for q in FB] for p in FA])\n",
    "assert np.allclose(sq_dists(FA, FB), loop), \"for 문으로 잰 값과 다릅니다\"\n",
    "assert np.array_equal(FA, f_tr[:7]) and np.array_equal(FB, f_tr[7:12]), \"입력 배열이 바뀌었습니다\"\n",
    "same = sq_dists(f_tr, f_tr)\n",
    "far = np.random.default_rng(1).normal(1000, 1, (5, 3))             # 원점에서 먼 점: 반올림 오차가 커진다\n",
    "assert min(same.min(), sq_dists(far, far).min()) >= 0, \"음수 거리²가 나왔습니다. 반올림 오차로 생긴 음수는 0으로 바꾸세요\"\n",
    "assert np.allclose(same, euclidean_distances(f_tr, f_tr, squared=True)), \"sklearn euclidean_distances(squared=True)와 다릅니다\"\n",
    "d2 = (f_tr[0] - f_tr[1]) ** 2\n",
    "z = StandardScaler().fit(f_tr).transform(f_tr[:2])\n",
    "z2 = (z[0] - z[1]) ** 2\n",
    "print(\"표본 0·1의 거리²에서 무게가 차지하는 비율: 원래\", round(d2[0] / d2.sum(), 3), \"/ 표준화 뒤\", round(z2[0] / z2.sum(), 3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `A @ B.T`가 모든 쌍의 내적을 한 번에 준다. `A[:, None, :] - B[None, :, :]`로도 같은 값이 나오지만 (m, n, d) 배열을 만들어 메모리가 d배 든다. 과일 데이터에서 무게는 표준편차가 50 정도, 산도는 0.1 정도라 표준화하지 않으면 거리²를 무게가 거의 다 차지한다. 무게는 특품 규칙에 없는 특성이다. 다음 문제에서 이것이 kNN 정확도를 어떻게 바꾸는지 본다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-010",
   "metadata": {},
   "source": [
    "## 문제 3. kNN 분류 직접 구현 (코드)\n",
    "\n",
    "`knn_predict(X_tr, y_tr, X_new, k)`를 쓰세요. `X_new`의 행마다 거리²가 가장 작은 훈련 표본 `k`개를 찾아 그 정답(0 이상 정수)의 다수결을 정수 배열(길이 `len(X_new)`)로 돌려줍니다.\n",
    "\n",
    "- 문제 2의 `sq_dists`를 씁니다.\n",
    "- 거리가 같으면 앞 번호 표본을, 표가 같으면 작은 범주를 고릅니다(`np.argsort(..., kind=\"stable\")`, `np.bincount(...).argmax()`가 그렇게 동작합니다).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`nn = np.argsort(sq_dists(X_new, X_tr), axis=1, kind=\"stable\")[:, :k]`는 (새 표본, k) 위치 배열입니다. 행마다 `np.bincount(y_tr[row]).argmax()`. 원고 8-4절과 같습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def knn_predict(X_tr, y_tr, X_new, k):\n",
    "    nn = np.argsort(sq_dists(X_new, X_tr), axis=1, kind=\"stable\")[:, :k]\n",
    "    return np.array([np.bincount(y_tr[row]).argmax() for row in nn])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "Xs3 = np.array([[0.0], [1.0], [2.0], [10.0], [11.0]])\n",
    "ys3 = np.array([0, 0, 1, 1, 1])\n",
    "r3 = knn_predict(Xs3, ys3, np.array([[0.4], [10.6], [1.6]]), 1)\n",
    "assert r3 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(r3, [0, 1, 1]), f\"k=1 작은 예에서 {r3}입니다. [0, 1, 1]이어야 합니다\"\n",
    "assert np.array_equal(knn_predict(Xs3, ys3, np.array([[1.4]]), 3), [0]), \"k=3이면 이웃 0·1·2의 정답 [0, 0, 1] 다수결로 0입니다\"\n",
    "assert np.array_equal(knn_predict(Xs3, ys3, np.array([[1.5]]), 2), [0]), \"표가 같으면(1.0과 2.0이 같은 거리) 작은 범주 0입니다\"\n",
    "assert np.array_equal(knn_predict(Xs3, np.array([0, 2, 2, 1, 1]), np.array([[0.9]]), 3), [2]), \"범주 3개: 이웃 정답 [0, 2, 2]의 다수결은 2입니다(평균이 아닙니다)\"\n",
    "assert np.array_equal(knn_predict(np.array([[0.0], [2.0]]), np.array([0, 1]), np.array([[1.0]]), 1), [0]), \"거리가 같은 이웃(0과 2)은 앞 번호 표본을 먼저 고릅니다\"\n",
    "sc3 = StandardScaler().fit(f_tr)\n",
    "z_tr, z_va = sc3.transform(f_tr), sc3.transform(f_va)\n",
    "Z0 = z_tr.copy()\n",
    "for k in [1, 5, 15]:\n",
    "    mine = knn_predict(z_tr, yf_tr, z_va, k)\n",
    "    assert np.array_equal(z_tr, Z0), \"입력 배열이 바뀌었습니다\"\n",
    "    assert np.shape(mine) == (len(z_va),), f\"모양이 {np.shape(mine)}입니다\"\n",
    "    ref = KNeighborsClassifier(n_neighbors=k).fit(z_tr, yf_tr).predict(z_va)\n",
    "    assert np.array_equal(mine, ref), f\"k={k}: sklearn과 {np.sum(mine != ref)}개 다릅니다\"\n",
    "    raw = knn_predict(f_tr, yf_tr, f_va, k)\n",
    "    print(f\"k={k:2d}: 표준화 없음 검증 {np.mean(raw == yf_va):.3f} / 표준화 검증 {np.mean(mine == yf_va):.3f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 직접 구현이 sklearn `KNeighborsClassifier`와 같은 예측을 낸다. 표준화 없이 재면 규칙에 거의 없는 무게가 이웃을 정해 정확도가 크게 떨어진다. 표준화(훈련 데이터에만 `fit`)하면 당도·지름·산도가 거리에 제 몫을 한다. 동점 규칙을 정해 두지 않으면 같은 코드도 라이브러리·정렬 방법에 따라 예측이 달라질 수 있다. 실무에서 실수 특성의 거리 동점은 드물지만, 정수 특성이나 중복 표본이 많으면 생긴다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-014",
   "metadata": {},
   "source": [
    "## 문제 4. 표준화 + kNN의 k를 교차검증으로 (코드)\n",
    "\n",
    "`cv_knn(X, y, ks, cv)`를 쓰세요. `ks`의 각 `k`마다 `make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k))`의 교차검증 **평균 정확도**를 구해 `{k: 평균 정확도}`(값은 `float`)로 돌려줍니다. 분할은 인자 `cv`를 그대로 씁니다.\n",
    "\n",
    "그다음 `pick_k(table)`로 평균 정확도가 가장 큰 `k`를 돌려줍니다. 같으면 **더 큰 k**(더 매끈한 경계, 더 단순한 모델)를 고릅니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "스케일러를 파이프라인 **안에** 넣어야 교차검증 조각마다 훈련 부분에만 맞춰집니다. 미리 `StandardScaler().fit_transform(X)`를 하고 넘기면 값이 조금 달라 점검에 걸립니다. `pick_k`는 `max(sorted(table, reverse=True), key=table.get)`이면 동점일 때 앞(큰 k)이 남습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def cv_knn(X, y, ks, cv):\n",
    "    out = {}\n",
    "    for k in ks:\n",
    "        model = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k))\n",
    "        out[k] = float(cross_val_score(model, X, y, cv=cv, scoring=\"accuracy\").mean())\n",
    "    return out\n",
    "\n",
    "def pick_k(table):\n",
    "    return max(sorted(table, reverse=True), key=table.get)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "ks = [1, 3, 5, 9, 15, 25, 45, 75]\n",
    "cv4 = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)\n",
    "X0 = f_tr.copy()\n",
    "tab4 = cv_knn(f_tr, yf_tr, ks, cv4)\n",
    "assert tab4 is not None, \"cv_knn: 결과를 return 하세요\"\n",
    "assert np.array_equal(f_tr, X0), \"입력 배열이 바뀌었습니다\"\n",
    "assert set(tab4) == set(ks), f\"키가 {sorted(tab4)}입니다. k마다 하나씩\"\n",
    "for k in ks:\n",
    "    ref = cross_val_score(make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k)), f_tr, yf_tr, cv=cv4).mean()\n",
    "    assert np.isclose(tab4[k], ref, rtol=0, atol=1e-12), f\"k={k}: {tab4[k]:.4f} ≠ 기대 {ref:.4f}. 스케일러를 파이프라인 안에 넣었나요?\"\n",
    "    assert type(tab4[k]) is float, \"값은 float로\"\n",
    "    print(f\"k={k:2d}: {tab4[k]:.4f}\")\n",
    "cv4b = StratifiedKFold(n_splits=3, shuffle=True, random_state=7)\n",
    "ref4b = cross_val_score(make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)), f_tr, yf_tr, cv=cv4b).mean()\n",
    "assert np.isclose(cv_knn(f_tr, yf_tr, [5], cv4b)[5], ref4b, rtol=0, atol=1e-12), \"다른 cv를 넘겼을 때 결과가 다릅니다. 인자 cv를 그대로 쓰세요\"\n",
    "assert pick_k({3: 0.8, 15: 0.9, 9: 0.9}) == 15, \"동점이면 더 큰 k입니다\"\n",
    "assert pick_k({1: 0.7, 5: 0.75, 25: 0.72}) == 5, \"평균 정확도가 가장 큰 k입니다\"\n",
    "best4 = pick_k(tab4)\n",
    "final = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=best4)).fit(f_tr, yf_tr)\n",
    "print(\"고른 k\", best4, \"/ 검증 정확도\", round(final.score(f_va, yf_va), 3),\n",
    "      \"/ k=1\", round(make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=1)).fit(f_tr, yf_tr).score(f_va, yf_va), 3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> k = 1은 이웃 하나의 잡음을 그대로 따라 분산이 크고, k가 너무 크면 먼 이웃까지 섞여 편향이 커진다. 가운데 어딘가가 가장 좋다. kNN에서는 k가 클수록 경계가 매끈하므로 동점이면 큰 k가 \"더 단순한 모델\"이다(07장 트리에서는 얕은 깊이였다). 스케일러를 파이프라인 밖에서 전체 훈련 데이터에 맞추면 교차검증의 검증 조각 정보가 평균·표준편차에 섞인다. 이 데이터에서는 차이가 작지만, 05장의 누수와 같은 구조라 습관으로 파이프라인에 넣는다. 고른 k로 훈련 데이터 전체에 다시 학습하고 검증 데이터로 한 번 잰다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-018",
   "metadata": {},
   "source": [
    "## 문제 5. k-평균 직접 구현 (코드)\n",
    "\n",
    "`kmeans(X, C0, max_iter)`를 쓰세요. 처음 중심 `C0`((k, d) 배열)에서 시작해 아래 한 바퀴를 **최대 `max_iter`바퀴** 되풀이하고 `(labels, C, inertia)`를 돌려줍니다.\n",
    "\n",
    "1. **할당**: 점마다 거리²가 가장 작은 중심의 번호(`argmin`, 같으면 작은 번호)를 구한다.\n",
    "2. 그 할당이 직전 바퀴의 `labels`와 같으면 여기서 멈춘다(첫 바퀴는 비교하지 않는다).\n",
    "3. `labels`를 새 할당으로 바꾸고, **갱신**: 중심 j = `labels == j`인 점들의 평균.\n",
    "\n",
    "예를 들어 `max_iter=1`이면 할당 1번 + 갱신 1번을 하고 멈춥니다.\n",
    "\n",
    "`inertia`는 각 점과 **최종** `C`에서 자기 중심(`labels`) 사이 거리²의 합(`float`)입니다. 무리가 비는 경우는 생각하지 않아도 됩니다. 입력 `C0`를 바꾸지 않습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 8-5절 `kmeans`와 같습니다. 할당 `new = sq_dists(X, C).argmin(axis=1)`, 갱신 `np.array([X[labels == j].mean(axis=0) for j in range(len(C))])`. inertia는 `sq_dists(X, C)[np.arange(len(X)), labels].sum()`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def kmeans(X, C0, max_iter=100):\n",
    "    C, labels = C0, None\n",
    "    for _ in range(max_iter):\n",
    "        new = sq_dists(X, C).argmin(axis=1)\n",
    "        if labels is not None and np.array_equal(new, labels):\n",
    "            break\n",
    "        labels = new\n",
    "        C = np.array([X[labels == j].mean(axis=0) for j in range(len(C))])\n",
    "    inertia = float(sq_dists(X, C)[np.arange(len(X)), labels].sum())\n",
    "    return labels, C, inertia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-020",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "X5 = np.array([[0.0, 0.0], [0.0, 1.0], [10.0, 0.0], [10.0, 1.0]])\n",
    "r5 = kmeans(X5, np.array([[0.0, 0.0], [10.0, 0.0]]))\n",
    "assert r5 is not None, \"결과를 return 하세요\"\n",
    "l5, c5, i5 = r5\n",
    "assert np.array_equal(l5, [0, 0, 1, 1]), f\"작은 예의 할당이 {l5}입니다\"\n",
    "assert np.allclose(c5, [[0, 0.5], [10, 0.5]]), f\"작은 예의 중심이 {np.round(c5, 3).tolist()}입니다. 무리의 평균으로 옮기세요\"\n",
    "assert np.isclose(i5, 1.0) and type(i5) is float, f\"작은 예의 inertia가 {i5}입니다. 최종 중심 기준 거리²의 합(float)은 1.0입니다\"\n",
    "X5b = np.array([[0.0], [1.0], [10.0], [11.0]])\n",
    "_, c5b, _ = kmeans(X5b, np.array([[0.0], [1.0]]), max_iter=1)\n",
    "assert np.allclose(c5b, [[0.0], [22 / 3]]), f\"max_iter=1이면 할당 1번 + 갱신 1번 하고 멈춥니다. 중심이 {np.round(c5b, 3).tolist()}\"\n",
    "_, c5c, _ = kmeans(X5b, np.array([[0.0], [1.0]]))\n",
    "assert np.allclose(c5c, [[0.5], [10.5]]), f\"끝까지 돌리면 중심은 [[0.5], [10.5]]입니다. 지금 {np.round(c5c, 3).tolist()}\"\n",
    "for seed in range(5):\n",
    "    C0 = Xk[np.random.default_rng(seed).choice(len(Xk), 3, replace=False)]\n",
    "    C00 = C0.copy()\n",
    "    labels, C, inertia = kmeans(Xk, C0)\n",
    "    assert np.array_equal(C0, C00), \"입력 C0가 바뀌었습니다\"\n",
    "    ref = KMeans(n_clusters=3, init=C0, n_init=1, tol=0).fit(Xk)\n",
    "    assert np.array_equal(labels, ref.labels_), f\"seed {seed}: 할당이 sklearn과 다릅니다\"\n",
    "    assert np.allclose(C, ref.cluster_centers_), f\"seed {seed}: 중심이 sklearn과 다릅니다\"\n",
    "    assert np.isclose(inertia, ref.inertia_), f\"seed {seed}: inertia {inertia:.2f} ≠ sklearn {ref.inertia_:.2f}\"\n",
    "    print(f\"처음 중심 seed {seed}: inertia {inertia:8.1f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 할당 단계는 중심을 고정하고 inertia를 줄이고, 갱신 단계는 할당을 고정하고 줄인다(거리² 합을 가장 작게 하는 점이 평균). 그래서 할당이 그대로가 되는 곳에서 멈춘다. sklearn과 비교할 때 `tol=0`을 준 것은 sklearn이 기본으로 \"중심이 아주 조금만 움직이면\" 일찍 멈추기 때문이다. 이 데이터는 덩어리가 잘 떨어져 있어 다섯 seed 모두 같은 결과였지만, 원고 8-5절처럼 처음 중심에 따라 inertia가 몇 배 큰 결과(지역 최솟값)가 나올 수 있다. 그래서 `n_init`으로 여러 번 돌리고 inertia가 가장 작은 것을 고른다(원고 8-5절). 무리가 비면 평균이 NaN이 되므로 실제 구현은 그 중심을 먼 점으로 옮기는 등의 처리를 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-022",
   "metadata": {},
   "source": [
    "## 문제 6. PCA로 줄이고 복원하기 (코드)\n",
    "\n",
    "두 함수를 쓰세요.\n",
    "\n",
    "- `choose_n(ratio, level)`: 설명된 분산 비율 배열 `ratio`(큰 순서)의 누적합이 처음으로 `level`을 **넘는** 주성분 수(1부터 센 `int`)를 돌려줍니다. sklearn `PCA(n_components=0.9)`가 개수를 고르는 규칙과 같습니다.\n",
    "- `pca_reduce(X_tr, X_new, n)`: `PCA(n_components=n)`을 **`X_tr`에만** 맞추고 `(Z_tr, Z_new, mse_new)`를 돌려줍니다. `Z_tr`, `Z_new`는 두 데이터를 투영한 좌표, `mse_new`는 `X_new`를 투영했다가 `inverse_transform`으로 되돌린 값과 `X_new`의 원소별 평균 제곱 오차(`float`)입니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`choose_n`: `int(np.searchsorted(np.cumsum(ratio), level, side=\"right\") + 1)`, 또는 앞에서부터 누적합을 더하다가 `> level`이 되는 위치 + 1. `pca_reduce`: `pca = PCA(n_components=n).fit(X_tr)`, `back = pca.inverse_transform(Z_new)`, `float(np.mean((back - X_new) ** 2))`. 원고 8-6절 \"줄인 뒤 모델에 넣기\"와 같습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def choose_n(ratio, level):\n",
    "    return int(np.searchsorted(np.cumsum(ratio), level, side=\"right\") + 1)\n",
    "\n",
    "def pca_reduce(X_tr, X_new, n):\n",
    "    pca = PCA(n_components=n).fit(X_tr)\n",
    "    Z_tr, Z_new = pca.transform(X_tr), pca.transform(X_new)\n",
    "    back = pca.inverse_transform(Z_new)\n",
    "    return Z_tr, Z_new, float(np.mean((back - X_new) ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "assert choose_n(np.array([0.6, 0.3, 0.1]), 0.85) == 2, \"누적 [0.6, 0.9, 1.0]에서 0.85를 처음 넘는 것은 2개째입니다\"\n",
    "assert choose_n(np.array([0.6, 0.3, 0.1]), 0.5) == 1, \"첫 주성분만으로 0.5를 넘으면 1입니다(1부터 셉니다)\"\n",
    "assert choose_n(np.array([0.7, 0.2, 0.1]), 0.7) == 2, \"누적이 level과 같으면 아직 '넘지' 않았습니다. 0.7을 넘는 것은 2개째입니다\"\n",
    "ratio_all = PCA().fit(g_tr).explained_variance_ratio_\n",
    "for level in [0.5, 0.8, 0.9, 0.95]:\n",
    "    n6 = choose_n(ratio_all, level)\n",
    "    assert type(n6) is int, \"파이썬 int로 돌려주세요\"\n",
    "    assert n6 == PCA(n_components=level).fit(g_tr).n_components_, f\"level {level}: {n6}개 ≠ sklearn {PCA(n_components=level).fit(g_tr).n_components_}개\"\n",
    "G0, V0 = g_tr.copy(), g_va.copy()\n",
    "r6 = pca_reduce(g_tr, g_va, 10)\n",
    "assert r6 is not None, \"pca_reduce: 결과를 return 하세요\"\n",
    "assert np.array_equal(g_tr, G0) and np.array_equal(g_va, V0), \"입력 배열이 바뀌었습니다\"\n",
    "Z_tr6, Z_va6, mse6 = r6\n",
    "assert np.shape(Z_tr6) == (len(g_tr), 10) and np.shape(Z_va6) == (len(g_va), 10), f\"좌표 모양: {np.shape(Z_tr6)}, {np.shape(Z_va6)}\"\n",
    "ref6 = PCA(n_components=10).fit(g_tr)\n",
    "assert np.allclose(Z_tr6, ref6.transform(g_tr)) and np.allclose(Z_va6, ref6.transform(g_va)), \"좌표가 훈련 데이터에만 맞춘 PCA의 transform과 다릅니다. X_new나 두 데이터를 합쳐 fit하지 않았나요?\"\n",
    "ref_mse = np.mean((ref6.inverse_transform(ref6.transform(g_va)) - g_va) ** 2)\n",
    "assert type(mse6) is float and np.isclose(mse6, ref_mse), f\"복원 오차 {mse6} ≠ 기대 {ref_mse:.4f}\"\n",
    "assert not np.isclose(pca_reduce(g_tr, g_va, 30)[2], mse6), \"n을 바꿔도 오차가 같습니다. 인자 n을 쓰세요\"\n",
    "print(\" 주성분  누적 비율  복원 MSE  kNN 검증 정확도\")\n",
    "for n_c in [2, 5, 10, 20, choose_n(ratio_all, 0.9), 40]:\n",
    "    Zt, Zv, mse = pca_reduce(g_tr, g_va, n_c)\n",
    "    acc = KNeighborsClassifier(n_neighbors=5).fit(Zt, yg_tr).score(Zv, yg_va)\n",
    "    print(f\"{n_c:6d} {ratio_all[:n_c].sum():9.3f} {mse:9.3f} {acc:12.3f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 주성분을 늘리면 담긴 분산이 늘고 복원 오차가 줄며, kNN 정확도는 어느 수준(대개 분산 90% 언저리)부터 거의 오르지 않는다. 2차원은 그림으로 보기에는 좋지만 분류에는 정보가 모자란다. PCA는 반드시 **훈련 데이터에만** `fit`하고, 검증·새 데이터에는 `transform`만 한다(05장 누수). 실무에서는 `make_pipeline(PCA(n_components=0.9), 모델)`처럼 파이프라인에 넣어 이 규칙을 저절로 지킨다. `choose_n`의 \"넘는다\"는 sklearn 구현의 규칙(누적합이 level보다 큰 첫 위치)을 따른 것이다. 주성분을 구하는 SVD·고유값의 수학은 수학 요청서의 선택 심화에 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-026",
   "metadata": {},
   "source": [
    "## 문제 7. 코사인 유사도 상위 k개 검색 (코드)\n",
    "\n",
    "`cosine_topk(Q, D, k)`를 쓰세요. 질문 벡터 `Q` (m, d)와 문서 벡터 `D` (n, d)로, 질문마다 코사인 유사도가 큰 순서대로 문서 위치 `k`개를 (m, k) 정수 배열로 돌려줍니다.\n",
    "\n",
    "- 각 행을 길이 1로 나눈 뒤 행렬곱 한 번으로 유사도를 구합니다(영벡터는 들어오지 않습니다).\n",
    "- 유사도가 같으면 **앞 번호** 문서를 먼저 둡니다.\n",
    "- 입력 `Q`, `D`를 바꾸지 않습니다(`/=`로 그 자리에서 나누면 안 됩니다).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`Qn = Q / np.linalg.norm(Q, axis=1, keepdims=True)`, 같은 방법으로 `Dn`. `S = Qn @ Dn.T`. 큰 순서이면서 동점은 앞 번호: `np.argsort(-S, axis=1, kind=\"stable\")[:, :k]`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def cosine_topk(Q, D, k):\n",
    "    Qn = Q / np.linalg.norm(Q, axis=1, keepdims=True)\n",
    "    Dn = D / np.linalg.norm(D, axis=1, keepdims=True)\n",
    "    S = Qn @ Dn.T\n",
    "    return np.argsort(-S, axis=1, kind=\"stable\")[:, :k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "D7 = np.array([[1.0, 0.0], [0.0, 1.0], [2.0, 0.0], [1.0, 1.0]])\n",
    "Q7 = np.array([[3.0, 0.1], [0.0, 5.0]])\n",
    "D70, Q70 = D7.copy(), Q7.copy()\n",
    "r7 = cosine_topk(Q7, D7, 3)\n",
    "assert r7 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(D7, D70) and np.array_equal(Q7, Q70), \"입력 배열이 바뀌었습니다\"\n",
    "assert np.shape(r7) == (2, 3), f\"모양이 {np.shape(r7)}입니다\"\n",
    "assert np.array_equal(r7[0], [0, 2, 3]), f\"첫 질문 결과 {r7[0]}: 문서 0과 2는 방향이 같아(길이만 다름) 유사도가 같고, 동점은 앞 번호입니다\"\n",
    "assert np.array_equal(r7[1], [1, 3, 0]), f\"둘째 질문 결과 {r7[1]}: 유사도가 큰 순서입니다\"\n",
    "rng7 = np.random.default_rng(0)\n",
    "Qr, Dr = rng7.normal(size=(20, 16)), rng7.normal(size=(300, 16))\n",
    "idx = NearestNeighbors(n_neighbors=5, metric=\"cosine\", algorithm=\"brute\").fit(Dr).kneighbors(Qr, return_distance=False)\n",
    "assert np.array_equal(cosine_topk(Qr, Dr, 5), idx), \"sklearn NearestNeighbors(metric='cosine')와 순서가 다릅니다\"\n",
    "top = cosine_topk(g_va, g_tr, 5)                                  # 검증 손글씨마다 비슷한 훈련 손글씨 5장\n",
    "same = np.mean(yg_tr[top] == yg_va[:, None])\n",
    "vote = np.array([np.bincount(yg_tr[row]).argmax() for row in top])\n",
    "print(f\"검색된 5장 중 같은 숫자 비율 {same:.3f} / 5장 다수결 정확도 {np.mean(vote == yg_va):.3f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 행을 정규화해 두면 질문 m개 × 문서 n개의 유사도가 행렬곱 한 번이다. 문서 0과 2처럼 방향이 같고 길이만 다른 벡터는 코사인 유사도가 같다. 손글씨에서 검색된 이웃의 대부분이 같은 숫자이고, 그 다수결이 곧 \"코사인 거리 kNN\"이다. 17장에서는 픽셀 대신 문장 임베딩으로 같은 검색을 하고, 검색된 문서를 LLM에 넘기는 것이 RAG다. 문서가 수백만 개면 이 전수 검색 대신 근사 최근접 검색(FAISS 등)을 쓴다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-030",
   "metadata": {},
   "source": [
    "## 문제 8. k-평균·PCA 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q8`에 적으세요.\n",
    "\n",
    "(a) k-평균의 inertia가 가장 작은 k를 고르면 가장 알맞은 무리 수다.\n",
    "(b) k-평균은 처음 중심에 따라 다른 결과가 나올 수 있어 `n_init`으로 여러 번 돌려 inertia가 가장 작은 결과를 쓴다.\n",
    "(c) PCA의 첫 주성분은 정답 라벨을 가장 잘 가르는 방향이다.\n",
    "(d) 단위가 서로 다른 특성을 표준화 없이 PCA하면, 값의 퍼짐이 가장 큰 특성이 첫 주성분을 차지하기 쉽다.\n",
    "(e) 주성분 벡터의 부호를 모두 반대로 바꿔도 같은 축을 나타낸다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q8 = \"XOXOO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"82d8e70f5137\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 가장 좋은 inertia는 k를 늘리면 늘지 않고 k = 표본 수에서 0이 된다(실제 실행은 초기화 때문에 예외가 있을 수 있다). 엘보·실루엣 점수·업무 쓸모로 고른다(원고 8-5절). (b) 지역 최솟값을 피하려는 것이다. (c) PCA는 라벨을 보지 않고 **분산이 큰 방향**을 찾는다. 정답에 중요한 정보가 분산이 작은 방향에 있을 수도 있다. (d) 원고 8-6절의 와인 proline(첫 주성분이 분산의 99.8%). (e) 축의 방향만 뒤집힌 것이라 좌표의 부호만 바뀐다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-034",
   "metadata": {},
   "source": [
    "## 문제 9. 연봉 하나로 갈린 고객 군집 (사례)\n",
    "\n",
    "분석 담당자가 고객 데이터(연봉(원), 나이(세), 한 달 방문 수)로 k-평균(k = 3)을 돌렸습니다. 무리별 평균을 보니 세 무리가 연봉 구간으로만 깔끔하게 나뉘고 나이·방문 수는 무리마다 거의 같았습니다. 보고서에는 \"우리 고객은 소득으로만 나뉜다\"고 적혀 있습니다. 가장 알맞은 판단을 `q9`에 적으세요.\n",
    "\n",
    "- A. 보고서가 맞다. k-평균이 찾은 무리이므로 데이터의 실제 구조다.\n",
    "- B. k를 10으로 늘리면 나이·방문 수에 따른 무리도 나올 것이다.\n",
    "- C. 연봉은 단위(원)가 커서 거리를 거의 혼자 정했다. 특성을 표준화(치우친 연봉은 로그 변환 뒤 표준화도 고려)하고 `n_init`을 여러 번 둬서 다시 군집한 뒤, 실루엣 점수와 업무 쓸모로 k를 정하고 무리별 특성 평균으로 해석한다. 군집은 정답이 아니므로 \"고객이 이렇게 나뉜다\"고 단정하지 않는다.\n",
    "- D. 연봉 열을 빼고 나이·방문 수만으로 군집한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"C\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"6b23c0d5f35d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 연봉의 표준편차는 수천만 원, 나이는 십여 세, 방문 수는 몇 회다. 표준화하지 않으면 거리²의 거의 전부가 연봉 차이라서 k-평균은 사실상 연봉 한 열만 나눈다(문제 2의 과일 무게와 같다). A는 결과를 데이터의 \"진짜 구조\"로 읽은 잘못이다. 군집은 특성·단위·k에 따라 달라진다. B는 k를 늘려도 연봉 구간이 더 잘게 나뉠 뿐이다. D는 원인(단위)을 고치지 않고 쓸모 있는 정보를 버린다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-038",
   "metadata": {},
   "source": [
    "## 문제 10. 상황별 방법 고르기 (사례)\n",
    "\n",
    "각 상황에 가장 알맞은 것을 고르세요. (a)~(e) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "- `K`: 표준화(또는 정규화) + kNN 분류\n",
    "- `M`: 표준화 + k-평균(`n_init` 여러 번)\n",
    "- `P`: 표준화 + PCA 2차원 그림\n",
    "- `C`: L2 정규화 + 코사인 유사도 상위 k개 검색\n",
    "- `T`: 트리 앙상블(HistGradientBoosting 등)\n",
    "\n",
    "(a) 라벨이 없는 회원 2만 명을 마케팅용 4~5개 그룹으로 나누고 싶다.\n",
    "(b) 상품 설명 문장 임베딩 10만 개에서 사용자 질문과 비슷한 상품 10개를 찾는다.\n",
    "(c) 센서 특성 300개짜리 공정 데이터를 그림 한 장으로 훑어보며 이상한 묶음이 있는지 보고 싶다.\n",
    "(d) 결측과 범주가 섞인 표 데이터 5만 건에서 이탈을 가장 잘 예측해야 한다.\n",
    "(e) 사전학습 모델로 뽑은 이미지 특징(512차원)과 라벨 붙은 사진 수백 장이 있다. 학습 없이 새 사진의 종류를 맞히는 기준선이 필요하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"MCPTK\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"b0c0478462b6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-041",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 라벨 없이 무리를 나누는 것은 군집이다. 표준화하고 여러 번 돌려 고르며, 무리 이름은 사람이 붙인다. (b) 임베딩은 방향이 뜻을 담으므로 정규화 + 코사인 유사도, 수가 더 많아지면 근사 검색(17장). (c) 차원이 많은 데이터를 둘러볼 때는 PCA 2차원. 겹쳐 보이는 것은 2차원의 한계일 수 있다. (d) 성능이 우선인 표 데이터 예측은 트리 앙상블이 기본이다(07장). kNN은 결측·범주·단위에 약하다. (e) 의미 있는 특징 공간이 이미 있으면 kNN(코사인 거리도 흔하다)이 학습 없이 바로 쓰는 강한 기준선이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-042",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 3에서 무게 열을 빼고(표준화 없이) kNN을 돌려 정확도가 얼마나 회복되는지 확인했다.\n",
    "- [ ] 문제 5에서 처음 중심 seed를 20개로 늘려 inertia가 몇 종류 나오는지 확인했다.\n",
    "- [ ] 문제 6의 `pca_reduce`로 손글씨를 20차원으로 줄인 뒤 문제 7의 검색을 다시 해 결과를 비교했다.\n",
    "- [ ] 원고 8-9절 선택 기준표의 다섯 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(09장)에서는 지금까지의 전처리·모델·평가를 `Pipeline`과 하이퍼파라미터 탐색으로 묶어 표 데이터를 기준선 → 개선 → 제출까지 끝낸다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
