{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch07-000",
   "metadata": {},
   "source": [
    "# 07장 실습. 트리와 앙상블\n",
    "\n",
    "**목표:** 지니 불순도와 가장 좋은 분할을 직접 계산해 sklearn 트리와 맞추고, 배깅·부스팅·순열 중요도를 NumPy로 구현한다. 트리의 복잡도를 교차검증으로 고르고, 특성 중요도와 모델 선택을 상황에 맞게 판단한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 배열을 바꾸지 않고** 새 값을 돌려준다.\n",
    "- 문제 3은 문제 2의 함수를 쓴다. 순서대로 푼다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안팎에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score\n",
    "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingRegressor\n",
    "from sklearn.inspection import permutation_importance\n",
    "from sklearn.metrics import log_loss\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",
    "# 가상의 쇼핑몰 재구매 데이터: 1500명, 재구매(1)가 약 36%\n",
    "rng = np.random.default_rng(7)\n",
    "n = 1500\n",
    "names = [\"회원번호\", \"방문수\", \"장바구니\", \"최근방문일\", \"쿠폰\", \"나이\"]\n",
    "Xs = np.column_stack([\n",
    "    rng.permutation(n) + 50000,          # 의미 없는 번호\n",
    "    rng.poisson(5, n),                   # 한 달 방문 수\n",
    "    rng.poisson(2, n),                   # 장바구니 담긴 상품 수\n",
    "    rng.integers(0, 60, n),              # 마지막 방문 후 지난 날\n",
    "    rng.integers(0, 2, n),               # 쿠폰 보유(0/1)\n",
    "    rng.integers(18, 70, n),             # 나이(규칙에 없음)\n",
    "]).astype(float)\n",
    "zs = (-2.0 + 2.5 * ((Xs[:, 3] <= 14) & (Xs[:, 1] >= 5)) + 1.5 * (Xs[:, 2] >= 3) + 1.0 * Xs[:, 4])\n",
    "ys = (rng.random(n) < 1 / (1 + np.exp(-zs))).astype(int)\n",
    "S_tr, S_va, ys_tr, ys_va = train_test_split(Xs, ys, test_size=0.3, stratify=ys, random_state=0)\n",
    "\n",
    "# 가상의 배달 시간(분) 데이터: 거리(km)·주문 수량으로 예측(회귀, 문제 6)\n",
    "xd = np.column_stack([rng.uniform(0.5, 8, 400), rng.uniform(1, 6, 400)])\n",
    "yd = 10 + 4 * xd[:, 0] + 6 * ((xd[:, 0] > 5) & (xd[:, 1] > 4)) + rng.normal(0, 2, 400)\n",
    "d_tr, d_va, yd_tr, yd_va = train_test_split(xd, yd, test_size=0.3, random_state=0)\n",
    "\n",
    "print(\"재구매 훈련\", S_tr.shape, \"검증\", S_va.shape, \"/ 재구매 비율\", round(ys.mean(), 3))\n",
    "print(\"배달 훈련\", d_tr.shape, \"검증\", d_va.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-002",
   "metadata": {},
   "source": [
    "## 문제 1. 결정 트리 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q1`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) 범주 0과 1이 반반인 노드의 지니 불순도는 0이다.\n",
    "(b) 결정 트리는 특성을 표준화하지 않아도 같은 분할을 찾는다(임계값의 단위만 다르다).\n",
    "(c) 깊이 제한이 없는 트리의 훈련 정확도가 1.0이면 새 데이터에서도 잘 맞는다고 볼 수 있다.\n",
    "(d) 트리의 질문은 \"특성 하나 ≤ 임계값\" 꼴이라 특성 2개 평면에서 경계는 축에 평행한 선분으로 이루어진다.\n",
    "(e) 회귀 트리(`DecisionTreeRegressor`)의 잎 예측값은 그 잎에 든 훈련 표본 y의 평균이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q1 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"82d8e70f5137\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-005",
   "metadata": {},
   "source": [
    "## 문제 2. 지니 불순도 (코드)\n",
    "\n",
    "`gini(y)`를 쓰세요. 0 이상 정수 범주 배열 `y`를 받아 지니 불순도 1 − Σ pₖ²를 파이썬 `float`로 돌려줍니다. 범주가 3개 이상이어도 됩니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`p = np.bincount(y) / len(y)`는 범주별 비율입니다(등장하지 않는 범주는 0이고, 0의 제곱은 0이라 결과에 영향이 없습니다). `float(1 - np.sum(p ** 2))`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def gini(y):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "y2 = np.array([1, 0, 1, 1, 0, 1])\n",
    "y20 = y2.copy()\n",
    "r2 = gini(y2)\n",
    "assert r2 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(y2, y20), \"입력 배열이 바뀌었습니다\"\n",
    "assert type(r2) is float, f\"파이썬 float로 돌려주세요(지금 {type(r2).__name__})\"\n",
    "assert np.isclose(r2, 1 - (2/6) ** 2 - (4/6) ** 2), f\"[0,0,1,1,1,1]에서 {r2}입니다\"\n",
    "assert np.isclose(gini(np.array([1, 1, 1])), 0.0), \"한 범주만 있으면 0입니다\"\n",
    "assert np.isclose(gini(np.array([0, 1, 2, 2])), 1 - 0.25 ** 2 - 0.25 ** 2 - 0.5 ** 2), \"범주 3개에서 다릅니다\"\n",
    "root = DecisionTreeClassifier(max_depth=1, random_state=0).fit(S_tr, ys_tr).tree_\n",
    "assert np.isclose(gini(ys_tr), root.impurity[0]), f\"재구매 훈련 데이터에서 {gini(ys_tr):.4f} ≠ sklearn 뿌리 불순도 {root.impurity[0]:.4f}\"\n",
    "print(\"재구매 훈련 데이터 뿌리 지니\", round(gini(ys_tr), 4))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-008",
   "metadata": {},
   "source": [
    "## 문제 3. 특성 하나의 가장 좋은 분할 (코드)\n",
    "\n",
    "`best_split_1d(x, y)`를 쓰세요. 특성 하나 `x`(1차원)와 범주 `y`로, 가중 지니(두 자식 지니를 표본 수로 가중 평균)가 가장 작은 분할 `(임계값, 가중 지니)`를 파이썬 `float` 두 개로 돌려줍니다.\n",
    "\n",
    "- 임계값 후보는 `x`의 서로 다른 값을 정렬했을 때 **이웃한 두 값의 가운데**입니다. 왼쪽은 `x <= 임계값`.\n",
    "- 점수가 같은 후보가 여럿이면 **가장 작은 임계값**을 고릅니다(앞에서부터 보며 더 작을 때만 바꾸면 됩니다).\n",
    "- `x`의 값이 모두 같아 나눌 수 없으면 `(None, gini(y))`를 돌려줍니다.\n",
    "- 문제 2의 `gini`를 씁니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`v = np.unique(x)`(정렬됨), `(v[:-1] + v[1:]) / 2`가 후보입니다. 후보마다 `left = x <= thr`, 점수 `(left.sum() * gini(y[left]) + (~left).sum() * gini(y[~left])) / len(y)`. 원고 7-4절 `best_split`에서 특성 반복만 뺀 것입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def best_split_1d(x, y):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-010",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "x3, y3 = np.array([1.0, 2.0, 3.0, 4.0]), np.array([0, 0, 1, 1])\n",
    "r3 = best_split_1d(x3, y3)\n",
    "assert r3 is not None, \"결과를 return 하세요\"\n",
    "assert np.isclose(r3[0], 2.5) and np.isclose(r3[1], 0.0), f\"작은 예에서 {r3}입니다. (2.5, 0.0)이어야 합니다\"\n",
    "r3n = best_split_1d(np.array([5.0, 5.0, 5.0]), np.array([0, 1, 1]))\n",
    "assert r3n[0] is None and np.isclose(r3n[1], gini(np.array([0, 1, 1]))), f\"나눌 수 없으면 (None, gini(y))입니다. 지금 {r3n}\"\n",
    "assert np.isclose(best_split_1d(np.array([1.0, 2.0, 3.0, 4.0]), np.array([0, 1, 0, 1]))[0], 1.5), \"점수가 같으면 가장 작은 임계값입니다\"\n",
    "for j in [1, 2, 3]:\n",
    "    xj = S_tr[:, j].copy()\n",
    "    thr, score = best_split_1d(S_tr[:, j], ys_tr)\n",
    "    assert np.array_equal(S_tr[:, j], xj), \"입력 배열이 바뀌었습니다\"\n",
    "    assert type(thr) is float and type(score) is float, \"파이썬 float 두 개로 돌려주세요\"\n",
    "    t = DecisionTreeClassifier(max_depth=1, random_state=0).fit(S_tr[:, [j]], ys_tr).tree_\n",
    "    L, R, nn = t.children_left[0], t.children_right[0], t.n_node_samples\n",
    "    ref = (nn[L] * t.impurity[L] + nn[R] * t.impurity[R]) / nn[0]\n",
    "    assert np.isclose(thr, t.threshold[0]), f\"{names[j]}: 임계값 {thr} ≠ sklearn {t.threshold[0]}\"\n",
    "    assert np.isclose(score, ref), f\"{names[j]}: 가중 지니 {score:.4f} ≠ sklearn {ref:.4f}\"\n",
    "    print(f\"{names[j]:6s} 임계값 {thr:5.1f}, 가중 지니 {score:.4f} (뿌리 {gini(ys_tr):.4f})\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-011",
   "metadata": {},
   "source": [
    "## 문제 4. 교차검증으로 max_depth 고르기 (코드)\n",
    "\n",
    "`cv_acc_by_depth(X, y, depths, cv)`를 쓰세요. `depths`의 각 깊이 `d`마다 `DecisionTreeClassifier(max_depth=d, random_state=0)`의 교차검증 **평균 정확도**를 구해 `{d: 평균 정확도}` 딕셔너리(값은 `float`)로 돌려줍니다. 분할은 인자 `cv`를 그대로 씁니다.\n",
    "\n",
    "그다음 `pick_depth(table)`로 평균 정확도가 가장 큰 깊이를 돌려줍니다. 같으면 **더 얕은 깊이**를 고릅니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`cross_val_score(model, X, y, cv=cv, scoring=\"accuracy\").mean()`. `pick_depth`는 `max(sorted(table), key=table.get)`이면 동점일 때 앞(작은 깊이)이 남습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def cv_acc_by_depth(X, y, depths, cv):\n",
    "    pass   # 작성\n",
    "\n",
    "def pick_depth(table):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "depths = [1, 2, 3, 4, 5, 6, 8, 12]\n",
    "cv4 = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)\n",
    "X0 = S_tr.copy()\n",
    "tab4 = cv_acc_by_depth(S_tr, ys_tr, depths, cv4)\n",
    "assert tab4 is not None, \"cv_acc_by_depth: 결과를 return 하세요\"\n",
    "assert np.array_equal(S_tr, X0), \"입력 배열이 바뀌었습니다\"\n",
    "assert set(tab4) == set(depths), f\"키가 {sorted(tab4)}입니다. 깊이마다 하나씩\"\n",
    "for d in depths:\n",
    "    ref = cross_val_score(DecisionTreeClassifier(max_depth=d, random_state=0), S_tr, ys_tr, cv=cv4).mean()\n",
    "    assert np.isclose(tab4[d], ref, rtol=0, atol=1e-12), f\"깊이 {d}: {tab4[d]:.4f} ≠ 기대 {ref:.4f}\"\n",
    "    print(f\"깊이 {d:2d}: {tab4[d]:.4f}\")\n",
    "cv4b = StratifiedKFold(n_splits=3, shuffle=True, random_state=7)\n",
    "ref4b = cross_val_score(DecisionTreeClassifier(max_depth=3, random_state=0), S_tr, ys_tr, cv=cv4b).mean()\n",
    "assert np.isclose(cv_acc_by_depth(S_tr, ys_tr, [3], cv4b)[3], ref4b, rtol=0, atol=1e-12), \"다른 cv를 넘겼을 때 결과가 다릅니다. 인자 cv를 그대로 쓰세요\"\n",
    "assert pick_depth({2: 0.8, 5: 0.9, 3: 0.9}) == 3, \"동점이면 더 얕은 깊이입니다\"\n",
    "assert pick_depth({1: 0.7, 4: 0.75}) == 4, \"평균 정확도가 가장 큰 깊이입니다\"\n",
    "best4 = pick_depth(tab4)\n",
    "final = DecisionTreeClassifier(max_depth=best4, random_state=0).fit(S_tr, ys_tr)\n",
    "deep = DecisionTreeClassifier(random_state=0).fit(S_tr, ys_tr)\n",
    "print(\"고른 깊이\", best4, \"/ 검증 정확도\", round(final.score(S_va, ys_va), 3), \"/ 제한 없는 트리\", round(deep.score(S_va, ys_va), 3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-014",
   "metadata": {},
   "source": [
    "## 문제 5. 배깅 직접 구현 (코드)\n",
    "\n",
    "`bagging_proba(X_tr, y_tr, X_new, n_trees, seed)`를 쓰세요. 아래 순서를 **정확히** 따릅니다.\n",
    "\n",
    "1. `rng = np.random.default_rng(seed)`를 한 번 만든다.\n",
    "2. 트리마다: `idx = rng.integers(0, N, N)`(N = 훈련 표본 수)로 부트스트랩 표본을 뽑고, `DecisionTreeClassifier(random_state=0)`을 `X_tr[idx]`, `y_tr[idx]`로 학습해 `X_new`의 `predict_proba(...)[:, 1]`을 구한다.\n",
    "3. `n_trees`개 확률의 **평균**(길이 `len(X_new)` 배열)을 돌려준다.\n",
    "\n",
    "(재구매 데이터는 1050명이라 부트스트랩에 두 범주가 모두 들어간다고 가정해도 됩니다.)\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "리스트에 확률을 모은 뒤 `np.mean(probs, axis=0)`. 원고 7-6절에서 랜덤 포레스트의 확률이 트리 확률의 평균임을 확인했습니다. 여기서는 특성 무작위 선택 없이 부트스트랩만 씁니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def bagging_proba(X_tr, y_tr, X_new, n_trees, seed):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "A0 = S_tr.copy()\n",
    "p5 = bagging_proba(S_tr, ys_tr, S_va, 3, seed=0)\n",
    "assert p5 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(S_tr, A0), \"입력 배열이 바뀌었습니다\"\n",
    "assert np.shape(p5) == (len(S_va),), f\"모양이 {np.shape(p5)}입니다. (len(X_new),)여야 합니다\"\n",
    "r5 = np.random.default_rng(0)\n",
    "manual = []\n",
    "for _ in range(3):\n",
    "    i5 = r5.integers(0, len(ys_tr), len(ys_tr))\n",
    "    manual.append(DecisionTreeClassifier(random_state=0).fit(S_tr[i5], ys_tr[i5]).predict_proba(S_va)[:, 1])\n",
    "assert np.allclose(p5, np.mean(manual, axis=0)), \"순서대로 만든 결과와 다릅니다. rng를 한 번만 만들고, 트리마다 integers(0, N, N)을 뽑았나요?\"\n",
    "assert np.allclose(bagging_proba(S_tr, ys_tr, S_va, 3, seed=0), p5), \"같은 seed면 결과가 같아야 합니다\"\n",
    "assert not np.allclose(bagging_proba(S_tr, ys_tr, S_va, 3, seed=1), p5), \"seed가 다르면 결과가 달라야 합니다. 인자 seed를 쓰세요\"\n",
    "p50 = bagging_proba(S_tr, ys_tr, S_va, 50, seed=0)\n",
    "p1 = DecisionTreeClassifier(random_state=0).fit(S_tr, ys_tr).predict_proba(S_va)[:, 1]\n",
    "acc1, acc50 = np.mean((p1 >= 0.5) == ys_va), np.mean((p50 >= 0.5) == ys_va)\n",
    "ll1, ll50 = log_loss(ys_va, np.clip(p1, 1e-15, 1 - 1e-15)), log_loss(ys_va, p50)\n",
    "assert ll50 < ll1, \"트리 50개 평균의 로그 손실이 트리 하나보다 커야 할 이유가 없습니다. 평균을 냈나요?\"\n",
    "print(f\"트리 1개(원 데이터): 정확도 {acc1:.3f}, 로그 손실 {ll1:.3f}\")\n",
    "print(f\"배깅 50개         : 정확도 {acc50:.3f}, 로그 손실 {ll50:.3f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-017",
   "metadata": {},
   "source": [
    "## 문제 6. 부스팅 직접 구현 (코드)\n",
    "\n",
    "배달 시간 데이터(회귀)에 쓸 부스팅을 만드세요.\n",
    "\n",
    "- `boost_fit(X, y, n_trees, lr, depth)`: F₀ = y의 평균에서 시작해, 트리마다 잔차 `y − F`에 `DecisionTreeRegressor(max_depth=depth, random_state=0)`을 맞추고 `F ← F + lr × (트리 예측)`. `(F0, trees)`를 돌려줍니다(`F0`는 `float`, `trees`는 트리 리스트).\n",
    "- `boost_predict(F0, trees, X, lr)`: F₀ + lr × (모든 트리 예측의 합).\n",
    "\n",
    "점검 셀은 sklearn `GradientBoostingRegressor(n_estimators, learning_rate, max_depth, random_state=0)`와 **훈련 데이터의** 예측을 비교합니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 7-7절 `boost`, `boost_predict`와 같습니다. `F = F + lr * t.predict(X)`처럼 새 배열을 만들면 입력이 안전합니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def boost_fit(X, y, n_trees, lr, depth):\n",
    "    pass   # 작성\n",
    "\n",
    "def boost_predict(F0, trees, X, lr):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "D0, y0 = d_tr.copy(), yd_tr.copy()\n",
    "res6 = boost_fit(d_tr, yd_tr, 50, 0.1, 2)\n",
    "assert res6 is not None, \"boost_fit: 결과를 return 하세요\"\n",
    "assert np.array_equal(d_tr, D0) and np.array_equal(yd_tr, y0), \"입력 배열이 바뀌었습니다\"\n",
    "F0, trees6 = res6\n",
    "assert np.isclose(F0, yd_tr.mean()), f\"F0가 {F0}입니다. y의 평균에서 시작합니다\"\n",
    "assert len(trees6) == 50, f\"트리가 {len(trees6)}개입니다. n_trees를 쓰세요\"\n",
    "assert trees6[0].get_depth() <= 2, \"depth를 max_depth로 쓰세요\"\n",
    "for n_t, lr, dep in [(50, 0.1, 2), (20, 0.3, 3), (5, 1.0, 1)]:\n",
    "    F0_, tr_ = boost_fit(d_tr, yd_tr, n_t, lr, dep)\n",
    "    mine = boost_predict(F0_, tr_, d_tr, lr)                         # 훈련 데이터에서 비교(해설 참고)\n",
    "    assert mine is not None, \"boost_predict: 결과를 return 하세요\"\n",
    "    ref = GradientBoostingRegressor(n_estimators=n_t, learning_rate=lr, max_depth=dep, random_state=0).fit(d_tr, yd_tr).predict(d_tr)\n",
    "    assert np.allclose(mine, ref, atol=1e-8), f\"트리 {n_t}개, lr {lr}, 깊이 {dep}: sklearn과 최대 {np.abs(mine - ref).max():.4f} 다릅니다. 잔차 y − F에 맞췄나요?\"\n",
    "F0c, trc = boost_fit(d_tr, yd_tr, 20, 0.3, 3)\n",
    "base6 = boost_predict(F0c, trc, d_va, 0.3)\n",
    "assert np.allclose(boost_predict(F0c + 7, trc, d_va, 0.3), base6 + 7), \"F0를 7 늘리면 예측도 7 늘어야 합니다. 인자 F0를 쓰세요\"\n",
    "assert np.allclose(base6, F0c + 0.3 * sum(t.predict(d_va) for t in trc)), \"검증 데이터 예측이 F0 + lr × (트리 예측의 합)과 다릅니다\"\n",
    "F0b, trb = boost_fit(d_tr, yd_tr, 300, 0.1, 2)\n",
    "print(\"트리 수  훈련 MSE  검증 MSE\")\n",
    "for k in [1, 10, 50, 300]:\n",
    "    mt = np.mean((boost_predict(F0b, trb[:k], d_tr, 0.1) - yd_tr) ** 2)\n",
    "    mv = np.mean((boost_predict(F0b, trb[:k], d_va, 0.1) - yd_va) ** 2)\n",
    "    print(f\"{k:6d} {mt:9.2f} {mv:9.2f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-020",
   "metadata": {},
   "source": [
    "## 문제 7. 순열 중요도 직접 구현 (코드)\n",
    "\n",
    "`perm_importance(model, X, y, n_repeats, seed)`를 쓰세요. 학습이 끝난 `model`의 `model.score(X, y)`(분류면 정확도)를 기준으로, 특성마다 다음을 계산해 길이 `X.shape[1]`의 배열을 돌려줍니다.\n",
    "\n",
    "1. `rng = np.random.default_rng(seed)`를 한 번 만든다.\n",
    "2. 특성 j마다 `n_repeats`번: `X`의 복사본을 만들어 j열만 `X[rng.permutation(len(X)), j]`로 섞고, (기준 점수 − 섞은 뒤 점수)를 구한다.\n",
    "3. 특성 j의 중요도 = 그 감소량들의 평균.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`Xp = X.copy()` 뒤 `Xp[:, j] = X[rng.permutation(len(X)), j]`. 원본 `X`는 건드리지 않습니다. 반복 순서는 \"특성 바깥, 반복 안쪽\"입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def perm_importance(model, X, y, n_repeats, seed):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-022",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "class FirstColumnOnly:                      # 첫 열 부호만 보는 가짜 모델\n",
    "    def score(self, X, y):\n",
    "        return np.mean((X[:, 0] > 0).astype(int) == y)\n",
    "\n",
    "X7 = np.random.default_rng(3).normal(size=(200, 3))\n",
    "y7 = (X7[:, 0] > 0).astype(int)\n",
    "X70 = X7.copy()\n",
    "r7 = perm_importance(FirstColumnOnly(), X7, y7, 5, seed=0)\n",
    "assert r7 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(X7, X70), \"입력 배열이 바뀌었습니다\"\n",
    "assert np.shape(r7) == (3,), f\"모양이 {np.shape(r7)}입니다. 특성 수만큼\"\n",
    "assert r7[0] > 0.3, f\"모델이 쓰는 첫 열의 중요도가 {r7[0]:.3f}입니다. 기준 − 섞은 뒤 점수인가요?\"\n",
    "assert np.allclose(r7[1:], 0), f\"모델이 쓰지 않는 열의 중요도는 정확히 0이어야 합니다: {r7[1:]}\"\n",
    "r7b = np.random.default_rng(0)\n",
    "exp0 = np.mean([1.0 - FirstColumnOnly().score(np.column_stack([X7[r7b.permutation(200), 0], X7[:, 1:]]), y7) for _ in range(5)])\n",
    "assert np.isclose(r7[0], exp0), \"섞는 순서가 다릅니다. rng를 한 번만 만들고 특성 0부터 n_repeats번 permutation을 뽑으세요\"\n",
    "\n",
    "class SecondColumnOnly:                     # 둘째 열 부호만 보는 가짜 모델\n",
    "    def score(self, X, y):\n",
    "        return np.mean((X[:, 1] > 0).astype(int) == y)\n",
    "\n",
    "y7s = (X7[:, 1] > 0).astype(int)\n",
    "r7s = perm_importance(SecondColumnOnly(), X7, y7s, 5, seed=0)\n",
    "r7c = np.random.default_rng(0)\n",
    "for _ in range(5):\n",
    "    r7c.permutation(200)                    # 특성 0 차례에 쓴 난수\n",
    "exp1 = np.mean([1.0 - SecondColumnOnly().score(np.column_stack([X7[:, 0], X7[r7c.permutation(200), 1], X7[:, 2]]), y7s) for _ in range(5)])\n",
    "assert np.isclose(r7s[1], exp1), \"둘째 특성의 값이 다릅니다. rng는 함수 처음에 한 번만 만들고, 특성마다 새로 만들지 않습니다\"\n",
    "assert not np.isclose(perm_importance(FirstColumnOnly(), X7, y7, 5, seed=1)[0], r7[0]), \"seed가 다르면 결과가 달라야 합니다\"\n",
    "rf7 = RandomForestClassifier(n_estimators=200, random_state=0, n_jobs=-1).fit(S_tr, ys_tr)\n",
    "mine7 = perm_importance(rf7, S_va, ys_va, 20, seed=0)\n",
    "sk7 = permutation_importance(rf7, S_va, ys_va, n_repeats=20, random_state=0).importances_mean\n",
    "assert np.allclose(mine7, sk7, atol=0.02), f\"sklearn permutation_importance와 크게 다릅니다: {np.round(mine7, 3)} / {np.round(sk7, 3)}\"\n",
    "print(\"특성       불순도   순열(직접)  순열(sklearn)\")\n",
    "for name, a, b, c in zip(names, rf7.feature_importances_, mine7, sk7):\n",
    "    print(f\"{name:6s} {a:8.3f} {b:+10.3f} {c:+12.3f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-023",
   "metadata": {},
   "source": [
    "## 문제 8. 앙상블·중요도 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q8`에 적으세요.\n",
    "\n",
    "(a) 랜덤 포레스트는 트리 수를 늘릴수록 과적합이 심해지므로 트리 수를 꼭 검증으로 골라야 한다.\n",
    "(b) 그래디언트 부스팅은 트리 수가 많으면 과적합할 수 있어 조기 종료를 쓴다.\n",
    "(c) OOB 점수는 각 표본을 그 표본을 부트스트랩에서 뽑지 않은 트리들로만 예측해 잰다.\n",
    "(d) 불순도 중요도(`feature_importances_`)가 높은 특성은 검증 데이터에서도 반드시 예측에 도움이 된다.\n",
    "(e) 부스팅의 학습률을 낮추면 같은 훈련 오차에 도달하는 데 대개 더 많은 트리가 필요하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q8 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"fbf0f35d8e41\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-026",
   "metadata": {},
   "source": [
    "## 문제 9. 회원번호가 가장 중요하다는 보고서 (사례)\n",
    "\n",
    "분석 담당자가 회원 이탈 예측 모델(랜덤 포레스트)을 만들고 `feature_importances_`를 막대그래프로 그려 보고했습니다. 1위가 \"회원번호\"(0.21), 2위가 \"최근 결제액\"(0.18)이었습니다. 보고서에는 \"회원번호가 이탈에 가장 큰 영향을 준다\"고 적혀 있습니다. 가장 알맞은 판단을 `q9`에 적으세요.\n",
    "\n",
    "- A. 보고서가 맞다. 회원번호 체계를 바꾸면 이탈이 줄 것이다.\n",
    "- B. 회원번호 열만 빼고 다시 학습하면 되고, 나머지 특성의 불순도 중요도 순위는 그대로 믿어도 된다.\n",
    "- C. 회원번호는 값이 모두 달라 불순도 중요도가 부풀려지기 쉬운 열이다. 검증 데이터의 순열 중요도로 다시 보고, 0 근처면 뺀다. 다만 번호가 가입 순서대로 매겨졌다면 가입 시기 정보를 담고 있을 수 있으니, 그렇다면 \"가입 기간\" 같은 뜻 있는 특성으로 바꾼다. 어느 경우든 중요도를 \"영향(원인)\"으로 쓰지 않는다.\n",
    "- D. 트리 수를 1000개로 늘리면 중요도가 바르게 나온다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"6b23c0d5f35d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-029",
   "metadata": {},
   "source": [
    "## 문제 10. 상황별 선택 (사례)\n",
    "\n",
    "각 상황에 가장 알맞은 것을 고르세요. (a)~(e) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "- `T`: 얕은 결정 트리(`max_depth` 3~4) + `export_text`\n",
    "- `R`: 랜덤 포레스트(기본값에 가깝게)\n",
    "- `H`: HistGradientBoosting + 조기 종료\n",
    "- `L`: 표준화 + 선형 모델\n",
    "- `P`: 검증 데이터 순열 중요도\n",
    "\n",
    "(a) 콜센터 상담원이 손으로 따라갈 수 있는 3~4단계 판정 규칙이 필요하다. 성능은 조금 낮아도 된다.\n",
    "(b) 50만 건, 특성 80개, 결측이 많은 표 데이터. 가장 높은 성능이 필요하고 학습 시간은 제한돼 있다.\n",
    "(c) 새 표 데이터에 로지스틱 회귀 기준선을 세웠다. 튜닝할 시간 없이 더 강한 모델 하나를 바로 비교해 보고 싶다.\n",
    "(d) 해마다 꾸준히 오르는 지역 평균 집값을 연도 등으로 학습해 **내년** 값을 예측해야 한다.\n",
    "(e) 이미 만든 모델이 어떤 특성에 기대는지 경영진에게 보고해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"194fd3da57ca\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-032",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 3에서 `gini` 대신 엔트로피로 바꿔 고르는 임계값이 달라지는지 확인했다.\n",
    "- [ ] 문제 5에서 `n_trees`를 1, 5, 20, 50으로 바꿔 검증 로그 손실이 어떻게 변하는지 확인했다.\n",
    "- [ ] 문제 6에서 학습률 0.3·1.0일 때 검증 MSE가 가장 작은 트리 수를 비교했다.\n",
    "- [ ] 원고 7-11절 선택 기준표의 다섯 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(08장)에서는 정답 없이 데이터의 구조를 찾는 거리 기반 방법(kNN, k-평균, PCA)을 다룬다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
