{
 "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 = \"XOXOO\""
   ]
  },
  {
   "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": [
    "> **해설**\n",
    ">\n",
    "> (a) 반반이면 지니가 가장 크다(1 − 0.5² − 0.5² = 0.5). 0은 한 범주만 남았을 때다. (b) 질문이 \"x ≤ 임계값\"뿐이라 양수 배·더하기(표준화)에는 같은 분할이 나오고 임계값만 그 단위로 바뀐다(원고 7-3절). 세제곱·로그처럼 순서만 지키는 변환은 훈련 표본을 나누는 방식은 같지만, 이웃한 두 값 사이에 오는 새 표본의 예측은 달라질 수 있다. (c) 제한 없는 트리는 잎마다 한 범주만 남을 때까지 나누므로 훈련 정확도 1.0은 당연하고, 잡음까지 외운 것일 수 있다. 검증으로 판단한다. (d) 그래서 원 모양 경계를 계단으로 근사한다. (e) 제곱 오차를 가장 작게 하는 상수가 평균이다. 분류 트리의 확률이 잎의 범주 비율인 것과 같은 생각이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-006",
   "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-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def gini(y):\n",
    "    p = np.bincount(y) / len(y)\n",
    "    return float(1 - np.sum(p ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-008",
   "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-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 범주 비율 p만 있으면 되므로 `np.bincount`가 가장 짧다. 재구매 비율이 약 0.36이면 지니는 1 − 0.36² − 0.64² ≈ 0.46이다. 이 값이 sklearn 트리의 `tree_.impurity[0]`(뿌리 노드 불순도)과 같다. 엔트로피로 바꾸려면 `p = p[p > 0]` 뒤 `np.sum(p * np.log2(1 / p))`(원고 7-4절)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-010",
   "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-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def best_split_1d(x, y):\n",
    "    v = np.unique(x)\n",
    "    best_thr, best_score = None, gini(y)\n",
    "    if len(v) < 2:\n",
    "        return best_thr, best_score\n",
    "    best_score = np.inf\n",
    "    for thr in (v[:-1] + v[1:]) / 2:\n",
    "        left = x <= thr\n",
    "        score = (left.sum() * gini(y[left]) + (~left).sum() * gini(y[~left])) / len(y)\n",
    "        if score < best_score:\n",
    "            best_thr, best_score = float(thr), float(score)\n",
    "    return best_thr, best_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-012",
   "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-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 세 특성 모두 sklearn의 깊이 1 트리(그루터기, stump)와 같은 분할을 찾는다. 최근방문일은 규칙의 문턱(14일)과 가까운 곳을, 장바구니는 3개 언저리를 고른다. 불순도가 가장 많이 줄어드는 특성이 트리의 뿌리 질문이 된다. 정수 특성이라 가운데 점이 x.5 꼴이고, 32비트로 바꿔도 정확히 표현되므로 sklearn과 완전히 같다(원고 7-4절에서는 실수 특성이라 뒷자리가 조금 달랐다). 이 함수는 후보마다 전체를 다시 세어 O(후보 수 × N)이다. sklearn은 정렬한 뒤 왼쪽 개수를 누적해 한 번 훑는 방식으로 빠르게 계산한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-014",
   "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-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def cv_acc_by_depth(X, y, depths, cv):\n",
    "    out = {}\n",
    "    for d in depths:\n",
    "        model = DecisionTreeClassifier(max_depth=d, random_state=0)\n",
    "        out[d] = float(cross_val_score(model, X, y, cv=cv, scoring=\"accuracy\").mean())\n",
    "    return out\n",
    "\n",
    "def pick_depth(table):\n",
    "    return max(sorted(table), key=table.get)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-016",
   "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-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 깊이 1~2는 규칙의 상호작용(최근 방문 **이면서** 방문수 많음)을 다 담지 못하고, 깊이가 커지면 잡음을 외워 교차검증 정확도가 떨어진다. 가운데 어딘가가 가장 좋다. 동점일 때 얕은 쪽을 고르는 것은 \"비슷하면 단순한 모델\"이라는 05·06장의 원칙이다. 고른 깊이로 훈련 데이터 전체에 다시 학습하고, 검증 데이터로 한 번 잰다. 제한 없는 트리보다 검증 정확도가 높을 것이다. `min_samples_leaf` 같은 다른 손잡이를 함께 찾으려면 9장의 `GridSearchCV`를 쓴다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-018",
   "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-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def bagging_proba(X_tr, y_tr, X_new, n_trees, seed):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    N = len(y_tr)\n",
    "    probs = []\n",
    "    for _ in range(n_trees):\n",
    "        idx = rng.integers(0, N, N)\n",
    "        tree = DecisionTreeClassifier(random_state=0).fit(X_tr[idx], y_tr[idx])\n",
    "        probs.append(tree.predict_proba(X_new)[:, 1])\n",
    "    return np.mean(probs, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-020",
   "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-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 트리 하나는 확률이 0·1뿐이라 로그 손실이 크다. 부트스트랩 트리 50개를 평균하면 확률이 0~1 사이로 퍼지고 분산이 줄어 정확도도 대개 오른다. 이것이 **배깅**이다(sklearn `BaggingClassifier`). 랜덤 포레스트는 여기에 노드마다 특성 일부만 보는 무작위성을 더해 트리끼리 덜 닮게 만든다. 트리들이 서로 비슷하면 평균해도 분산이 별로 줄지 않기 때문이다. 부트스트랩에 들지 않은 표본(약 37%)으로 각 트리를 채점하면 OOB 점수가 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-022",
   "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-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def boost_fit(X, y, n_trees, lr, depth):\n",
    "    F0 = float(y.mean())\n",
    "    F, trees = np.full(len(y), F0), []\n",
    "    for _ in range(n_trees):\n",
    "        t = DecisionTreeRegressor(max_depth=depth, random_state=0).fit(X, y - F)\n",
    "        F = F + lr * t.predict(X)\n",
    "        trees.append(t)\n",
    "    return F0, trees\n",
    "\n",
    "def boost_predict(F0, trees, X, lr):\n",
    "    return F0 + lr * sum(t.predict(X) for t in trees)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-024",
   "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-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 점검이 훈련 데이터로 비교한 이유: 깊이 3 이상에서는 한 노드의 훈련 표본을 **똑같이** 나누는 질문이 둘 이상인 경우가 있다(예: 표본 몇 개를 거리로 나누든 주문 수량으로 나누든 같은 두 무리가 됨). 손실이 같은 동점이라 어느 질문을 고를지는 특성을 살펴보는 순서(난수)에 달렸고, 직접 만든 트리와 sklearn 내부 트리는 그 난수가 다르다. 훈련 데이터에서는 나뉜 결과가 같아 예측이 똑같지만, 검증 데이터에서는 두 질문이 다르게 나눠 예측이 조금 달라진다(이 데이터에서 트리 20개·깊이 3일 때 검증 예측 최대 0.41분 차이를 확인했다).\n",
    "> \n",
    "> `trb[:k]`로 앞의 트리 k개만 쓰면 sklearn `staged_predict`와 같은 단계별 예측이 된다. 훈련 MSE는 트리를 더할수록 계속 줄고, 검증 MSE는 어느 지점부터 더 나아지지 않는다. 새 표본에 대한 **기대** 제곱 오차는 잡음 분산 2² = 4보다 작을 수 없지만, 검증 표본 120개로 잰 MSE는 우연히 그보다 작을 수도 있다(정답 규칙으로 예측해도 이 검증 데이터의 MSE는 약 3.5다). 학습률을 크게(1.0) 하면 트리 몇 개로 빨리 맞추지만 과적합도 빠르다. 실무에서는 작은 학습률 + 조기 종료로 트리 수를 정한다(원고 7-7절). 분류 부스팅은 잔차 자리에 로그 손실 기울기(06장의 p − y)의 반대 방향 y − p를 쓰고 점수 F를 시그모이드로 확률로 바꾼다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-026",
   "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-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def perm_importance(model, X, y, n_repeats, seed):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    base = model.score(X, y)\n",
    "    out = np.zeros(X.shape[1])\n",
    "    for j in range(X.shape[1]):\n",
    "        drops = []\n",
    "        for _ in range(n_repeats):\n",
    "            Xp = X.copy()\n",
    "            Xp[:, j] = X[rng.permutation(len(X)), j]\n",
    "            drops.append(base - model.score(Xp, y))\n",
    "        out[j] = np.mean(drops)\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-028",
   "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-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 직접 구현과 sklearn은 섞는 난수가 달라 값이 조금 다르지만 순위와 크기는 같다. 불순도 중요도에서는 **회원번호**가 나이와 함께 꽤 높게 나오지만, 검증 데이터 순열 중요도로는 0 근처다. 값이 모두 다른 열은 깊은 트리가 표본 몇 개를 가르는 데 쓰기 쉬워 불순도 중요도가 부풀려진다(원고 7-8절). 규칙에 없는 나이도 값의 종류가 많아 불순도 중요도가 높다. 반대로 쿠폰(0/1)처럼 값이 두 개뿐인 열은 불순도 중요도가 낮게 나오기 쉽다. 다만 0.01~0.02 정도의 순열 중요도는 섞을 때마다의 흔들림과 비슷한 크기라, 이 크기끼리의 순위(쿠폰·나이·회원번호)는 단정하지 않는다. sklearn은 `scoring`으로 정확도 대신 AUC 등을 쓸 수 있고, 반복마다의 값(`importances`)과 표준편차도 준다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-030",
   "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-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q8 = \"XOOXO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"fbf0f35d8e41\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 트리 수를 늘려도 평균이 안정될 뿐 과적합이 심해지지 않는다. 시간이 허락하는 만큼 크게 둔다(원고 7-6절). (b) 부스팅은 앞 트리가 틀린 것을 계속 고치므로 결국 잡음까지 맞춘다(원고 7-7절). (c) 그래서 검증 데이터를 따로 떼지 않고도 일반화 성능을 어림한다. (d) 불순도 중요도는 훈련 데이터 기준이라 회원번호처럼 의미 없는 열도 높게 나올 수 있다(문제 7). (e) 한 트리가 고치는 양이 lr배로 줄기 때문이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-034",
   "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-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"C\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"6b23c0d5f35d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> A는 중요도를 인과로 읽은 잘못이다. 중요도는 \"모델이 그 열을 썼다\"는 뜻일 뿐이다. B는 반쪽이다. 불순도 중요도는 값의 종류가 많은 다른 숫자 열(예: 결제액)도 부풀릴 수 있으니 남은 순위도 순열 중요도로 확인한다. D: 트리 수는 중요도의 흔들림을 줄일 뿐 불순도 중요도의 치우침은 그대로다. ID처럼 보이는 열이 실제로 정보를 담는 경우(가입 순서, 지점 코드가 붙은 번호)도 흔하다. 그런 정보는 뜻이 분명한 특성으로 바꿔 넣어야, 새 회원이 들어왔을 때(번호가 훈련 범위를 벗어날 때) 모델이 무너지지 않는다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-038",
   "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-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"THRLP\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch07-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"194fd3da57ca\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-041",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 질문 몇 개로 된 트리는 그대로 규칙표가 된다. (b) 데이터가 크고 결측이 많으며 성능이 우선이면 HistGradientBoosting. 1만 건이 넘으면 조기 종료가 기본으로 켜진다. (c) 랜덤 포레스트는 기본값으로도 대체로 강해 \"튜닝 없는 두 번째 기준선\"으로 알맞다. (d) 내년 값은 훈련 범위 밖이라 트리는 외삽하지 못한다(원고 7-9절). 추세를 선형 모델로 잡는다. (e) 검증 데이터 순열 중요도로 보고하고, 원인이 아니라 \"모델이 쓴 정도\"라고 함께 적는다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch07-042",
   "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
}
