{
 "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 = None"
   ]
  },
  {
   "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": [
    "## 문제 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-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def sq_dists(A, B):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-007",
   "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-008",
   "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-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def knn_predict(X_tr, y_tr, X_new, k):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-010",
   "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-011",
   "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-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def cv_knn(X, y, ks, cv):\n",
    "    pass   # 작성\n",
    "\n",
    "def pick_k(table):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-013",
   "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-014",
   "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-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def kmeans(X, C0, max_iter=100):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-016",
   "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-017",
   "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-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def choose_n(ratio, level):\n",
    "    pass   # 작성\n",
    "\n",
    "def pca_reduce(X_tr, X_new, n):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-019",
   "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-020",
   "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-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def cosine_topk(Q, D, k):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-022",
   "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-023",
   "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-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q8 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"82d8e70f5137\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-026",
   "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-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"6b23c0d5f35d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-029",
   "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-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch08-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"b0c0478462b6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch08-032",
   "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
}
