{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch09-000",
   "metadata": {},
   "source": [
    "# 09장 실습. 표 데이터 실전 파이프라인\n",
    "\n",
    "**목표:** 가상 헬스장 회원 데이터로 재등록 여부(분류)를 예측해 확률을 제출한다. 열마다 다른 전처리를 `ColumnTransformer`로, 특성 만들기·전처리·모델을 `Pipeline`으로 묶고, 같은 교차검증 조각으로 기준선과 비교하고, `GridSearchCV`로 탐색하고, id로 맞춘 제출 파일을 만들고, 저장한 모델을 다시 불러 같은 예측을 확인한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 표를 바꾸지 않고** 새 값을 돌려준다.\n",
    "- 문제 4~7은 문제 2·3의 함수를 쓴다. 순서대로 푼다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안팎에 끝난다. 작업 폴더에 `gym_bundle.joblib`, `gym_features.py`, `gym_check.py`가 생긴다(다 끝나면 지워도 된다)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib, sys, subprocess\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn, joblib\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.pipeline import Pipeline, make_pipeline\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder, FunctionTransformer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import HistGradientBoostingClassifier\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score, GridSearchCV\n",
    "from sklearn.metrics import roc_auc_score\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",
    "# 가상 헬스장 회원 4000명. 기준일(2025-06-30)에 회원권이 끝나며, 재등록(1) 여부를 예측한다.\n",
    "# 규칙: 주당 방문이 많을수록, 마지막 방문이 최근일수록, 12개월 회원권일수록 재등록. 성별·월회비는 직접 영향 없음.\n",
    "REF = \"2025-06-30\"\n",
    "rng = np.random.default_rng(9)\n",
    "n = 4000\n",
    "branches = [\"강남\", \"홍대\", \"잠실\", \"분당\", \"일산\", \"수원\"]\n",
    "plans = [\"1개월\", \"3개월\", \"6개월\", \"12개월\"]\n",
    "start = pd.Timestamp(\"2024-01-01\") + pd.to_timedelta(rng.integers(0, 480, n), unit=\"D\")\n",
    "span = (pd.Timestamp(REF) - start).days\n",
    "last = start + pd.to_timedelta((rng.uniform(0.2, 1.0, n) * span).astype(int), unit=\"D\")\n",
    "weeks = (last - start).days / 7 + 1\n",
    "per_week = rng.gamma(2.0, 0.8, n)\n",
    "plan = rng.choice(plans, n, p=[0.35, 0.3, 0.2, 0.15])\n",
    "gym = pd.DataFrame({\n",
    "    \"id\": rng.permutation(n) + 50001,\n",
    "    \"지점\": rng.choice(branches, n, p=[0.25, 0.2, 0.2, 0.15, 0.1, 0.1]),\n",
    "    \"회원권\": plan,\n",
    "    \"나이\": rng.integers(18, 70, n).astype(float),\n",
    "    \"성별\": rng.choice([\"여\", \"남\"], n),\n",
    "    \"월회비\": pd.Series(plan).map({\"1개월\": 99000, \"3개월\": 89000, \"6개월\": 79000, \"12개월\": 69000}).to_numpy()\n",
    "             + rng.integers(-5, 6, n) * 1000,\n",
    "    \"가입일\": start.strftime(\"%Y-%m-%d\"),\n",
    "    \"마지막방문일\": last.strftime(\"%Y-%m-%d\"),\n",
    "    \"방문횟수\": rng.poisson(per_week * weeks),\n",
    "})\n",
    "idle = (pd.Timestamp(REF) - last).days\n",
    "z = (0.2 + 1.3 * (gym[\"방문횟수\"] / weeks - 1.6) - 0.025 * idle + 1.0 * (plan == \"12개월\")\n",
    "     - 0.6 * (plan == \"1개월\") + rng.normal(0, 1.8, n))\n",
    "gym[\"재등록\"] = (z > 0).astype(int)\n",
    "gym.loc[rng.random(n) < 0.07, \"나이\"] = np.nan\n",
    "gym.loc[rng.random(n) < 0.04, \"지점\"] = np.nan\n",
    "\n",
    "g_train = gym.iloc[:3000].reset_index(drop=True)\n",
    "g_test = gym.iloc[3000:].drop(columns=\"재등록\").reset_index(drop=True)\n",
    "g_test.loc[[3, 300, 600], \"지점\"] = \"부산\"                                # 훈련에 없는 지점\n",
    "g_sample = pd.DataFrame({\"id\": np.sort(g_test[\"id\"].to_numpy()), \"재등록\": 0.5})   # 제출 양식: id 오름차순\n",
    "Xg = g_train.drop(columns=[\"id\", \"재등록\"])\n",
    "yg = g_train[\"재등록\"]\n",
    "Xg_dev, Xg_hold, yg_dev, yg_hold = train_test_split(Xg, yg, test_size=0.2, stratify=yg, random_state=0)\n",
    "cvg = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)\n",
    "print(\"훈련\", g_train.shape, \"/ 테스트\", g_test.shape, \"/ 양식\", g_sample.shape, \"/ 재등록 비율\", round(yg.mean(), 3))\n",
    "print(\"결측\", g_train.isna().sum()[lambda s: s > 0].to_dict(), \"/ 테스트에만 있는 지점\", set(g_test[\"지점\"].dropna()) - set(g_train[\"지점\"].dropna()))\n",
    "print(g_train.head(3).to_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-002",
   "metadata": {},
   "source": [
    "## 문제 1. 파이프라인·누수 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q1`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) `Pipeline`을 `cross_val_score`에 넘기면 조각마다 전처리도 그 조각의 훈련 부분으로만 다시 `fit`된다.\n",
    "(b) `ColumnTransformer`의 `remainder` 기본값은 `\"passthrough\"`라서 목록에 없는 열도 그대로 모델에 들어간다.\n",
    "(c) `OneHotEncoder(handle_unknown=\"ignore\")`는 테스트에 처음 보는 범주가 오면 그 범주의 원-핫 열을 모두 0으로 둔다.\n",
    "(d) 행마다 계산하는 특성(예: 방문횟수 ÷ 이용주)은 데이터 전체의 통계를 쓰지 않으므로 교차검증 밖에서 만들어도 누수가 생기지 않는다.\n",
    "(e) \"지점별 재등록 비율\" 특성은 정답을 쓰지만, 훈련 데이터 전체에서 한 번 계산해 교차검증에 넣어도 점수에는 영향이 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q1 = \"OXOOX\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"9861f5c5fe42\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-005",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 파이프라인을 쓰는 가장 큰 이유다(원고 9-4절). (b) 기본값은 `\"drop\"`이다. 버릴 열을 명시적으로 정하는 효과가 있다. (c) 원고 9-4절의 포르쉐 행. (d) 행 하나의 값만 쓰는 계산은 `fit`할 것이 없어 어디서 해도 같다(원고 9-5절). 다만 훈련·예측에 같은 규칙을 적용하려면 파이프라인 안에 넣는 편이 안전하다. (e) 정답을 쓰는 통계를 검증 조각까지 포함해 계산하면 검증 표본의 정답이 특성에 새어 들어간다(05장 누수). 조각마다 훈련 부분으로만 계산해야 한다(`TargetEncoder`가 그렇게 한다). 문제 9에서 다시 본다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-006",
   "metadata": {},
   "source": [
    "## 문제 2. 열마다 다른 전처리 (코드)\n",
    "\n",
    "`make_prep(num_cols, cat_cols)`를 쓰세요. 아직 `fit`하지 않은 `ColumnTransformer`를 돌려줍니다.\n",
    "\n",
    "- `\"num\"`: `num_cols`를 중앙값으로 채우고(`SimpleImputer(strategy=\"median\")`) 표준화(`StandardScaler`)\n",
    "- `\"cat\"`: `cat_cols`를 가장 흔한 값으로 채우고(`strategy=\"most_frequent\"`) 원-핫(`OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False)`)\n",
    "- 나머지 열은 버립니다. 변환 순서는 `\"num\"` → `\"cat\"`.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`ColumnTransformer([(\"num\", make_pipeline(SimpleImputer(...), StandardScaler()), num_cols), (\"cat\", make_pipeline(...), cat_cols)])`. 원고 9-4절 `linear_prep`과 같은 구조입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def make_prep(num_cols, cat_cols):\n",
    "    return ColumnTransformer([\n",
    "        (\"num\", make_pipeline(SimpleImputer(strategy=\"median\"), StandardScaler()), num_cols),\n",
    "        (\"cat\", make_pipeline(SimpleImputer(strategy=\"most_frequent\"),\n",
    "                              OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False)), cat_cols),\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-008",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "base_num, base_cat = [\"나이\", \"월회비\", \"방문횟수\"], [\"지점\", \"회원권\"]\n",
    "p2 = make_prep(base_num, base_cat)\n",
    "assert p2 is not None, \"결과를 return 하세요\"\n",
    "assert isinstance(p2, ColumnTransformer), \"ColumnTransformer를 돌려주세요\"\n",
    "assert not hasattr(p2, \"transformers_\"), \"fit하지 않은 객체를 돌려주세요(fit은 쓰는 쪽에서 합니다)\"\n",
    "D0 = Xg_dev.copy()\n",
    "Z2 = p2.fit_transform(Xg_dev)\n",
    "assert Xg_dev.equals(D0), \"입력 표가 바뀌었습니다\"\n",
    "assert Z2.shape == (len(Xg_dev), 3 + 6 + 4), f\"모양이 {Z2.shape}입니다. 숫자 3 + 지점 6 + 회원권 4 = 13열이어야 합니다(나머지 열은 버림)\"\n",
    "assert not np.isnan(Z2).any(), \"결측이 남았습니다. 숫자는 중앙값, 범주는 최빈값으로 채우세요\"\n",
    "med = Xg_dev[\"나이\"].median()\n",
    "assert np.isclose(p2.named_transformers_[\"num\"][0].statistics_[0], med), \"나이를 채운 값이 개발 데이터의 중앙값이 아닙니다\"\n",
    "assert np.allclose(Z2[:, :3].mean(axis=0), 0, atol=1e-9) and np.allclose(Z2[:, :3].std(axis=0), 1), \"숫자 열을 표준화하세요(num 먼저)\"\n",
    "ref = ColumnTransformer([(\"num\", make_pipeline(SimpleImputer(strategy=\"median\"), StandardScaler()), base_num),\n",
    "                         (\"cat\", make_pipeline(SimpleImputer(strategy=\"most_frequent\"),\n",
    "                                               OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False)), base_cat)]).fit(Xg_dev)\n",
    "assert np.allclose(p2.transform(Xg_hold), ref.transform(Xg_hold)), \"홀드아웃 변환이 기대와 다릅니다. 개발 데이터로 맞춘 값을 그대로 써야 합니다\"\n",
    "busan = p2.transform(g_test.iloc[[3]])\n",
    "assert np.allclose(busan[0, 3:9], 0), \"처음 보는 지점(부산)은 지점 열이 모두 0이어야 합니다(handle_unknown='ignore')\"\n",
    "print(\"열 이름 일부:\", list(p2.get_feature_names_out()[[0, 3, 9]]))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 숫자와 범주를 다른 방법으로 채우고 바꾼 뒤 옆으로 잇는다. 채우는 값(중앙값·최빈값)과 범주 목록은 `fit`한 개발 데이터에서 정해지고, 홀드아웃·테스트에는 그 값을 그대로 쓴다. 성별·날짜 열은 목록에 없어 버려졌다. 처음 보는 지점 \"부산\"은 지점 열이 모두 0인 행이 된다. 결측 지점은 최빈값으로 채웠는데, 결측 자체가 정보일 수 있으면 `SimpleImputer(strategy=\"constant\", fill_value=\"없음\")`처럼 별도 범주로 두는 방법도 있다(03장의 결측 표시와 같은 생각)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-010",
   "metadata": {},
   "source": [
    "## 문제 3. 날짜·비율 특성 (코드)\n",
    "\n",
    "`add_features(df)`를 쓰세요. `df`를 복사해 아래 세 열을 더한 표를 돌려줍니다. 입력 `df`는 바꾸지 않습니다. 기준일은 위에서 정한 `REF`(`\"2025-06-30\"`)입니다.\n",
    "\n",
    "- `이용주` = (마지막방문일 − 가입일)의 일수 / 7 + 1\n",
    "- `주당방문` = 방문횟수 / 이용주\n",
    "- `휴면일` = (기준일 − 마지막방문일)의 일수\n",
    "\n",
    "날짜 열은 문자열이므로 `pd.to_datetime`으로 바꿉니다. 날짜끼리 뺀 결과에서 `.dt.days`로 일수를 얻습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`out = df.copy()`, `s = pd.to_datetime(out[\"가입일\"])`, `l = pd.to_datetime(out[\"마지막방문일\"])`, `out[\"이용주\"] = (l - s).dt.days / 7 + 1`, `out[\"휴면일\"] = (pd.Timestamp(REF) - l).dt.days`. 원고 9-5절 `add_features`와 같은 모양입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def add_features(df):\n",
    "    out = df.copy()\n",
    "    s = pd.to_datetime(out[\"가입일\"])\n",
    "    l = pd.to_datetime(out[\"마지막방문일\"])\n",
    "    out[\"이용주\"] = (l - s).dt.days / 7 + 1\n",
    "    out[\"주당방문\"] = out[\"방문횟수\"] / out[\"이용주\"]\n",
    "    out[\"휴면일\"] = (pd.Timestamp(REF) - l).dt.days\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "toy = pd.DataFrame({\"가입일\": [\"2025-01-01\", \"2025-06-01\"], \"마지막방문일\": [\"2025-01-15\", \"2025-06-30\"], \"방문횟수\": [6, 10]})\n",
    "toy0 = toy.copy()\n",
    "r3 = add_features(toy)\n",
    "assert r3 is not None, \"결과를 return 하세요\"\n",
    "assert toy.equals(toy0), \"입력 표가 바뀌었습니다. df.copy()에 열을 더하세요\"\n",
    "for col in [\"이용주\", \"주당방문\", \"휴면일\"]:\n",
    "    assert col in r3.columns, f\"{col} 열이 없습니다\"\n",
    "assert np.allclose(r3[\"이용주\"], [14 / 7 + 1, 29 / 7 + 1]), f\"이용주가 {r3['이용주'].tolist()}입니다. 일수 / 7 + 1\"\n",
    "assert np.allclose(r3[\"주당방문\"], [6 / 3, 10 / (29 / 7 + 1)]), f\"주당방문이 {r3['주당방문'].round(3).tolist()}입니다\"\n",
    "assert np.allclose(r3[\"휴면일\"], [166, 0]), f\"휴면일이 {r3['휴면일'].tolist()}입니다. 기준일 REF − 마지막방문일의 일수\"\n",
    "assert list(r3.columns[:3]) == [\"가입일\", \"마지막방문일\", \"방문횟수\"], \"원래 열은 그대로 두고 새 열을 더하세요\"\n",
    "F3 = add_features(Xg_dev)\n",
    "assert len(F3) == len(Xg_dev) and (F3.index == Xg_dev.index).all(), \"행 수·인덱스를 바꾸지 마세요\"\n",
    "assert list(F3.columns[:Xg_dev.shape[1]]) == list(Xg_dev.columns), \"원래 열(나이·지점·회원권 등)을 모두 그 순서대로 두고 새 열을 뒤에 더하세요\"\n",
    "assert F3[list(Xg_dev.columns)].equals(Xg_dev), \"원래 열의 값이 바뀌었습니다\"\n",
    "print(F3[[\"주당방문\", \"휴면일\"]].describe().loc[[\"mean\", \"50%\", \"max\"]].round(2).to_string())\n",
    "print(\"재등록 여부별 평균 주당방문:\", add_features(Xg).groupby(yg)[\"주당방문\"].mean().round(2).to_dict())\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 날짜 문자열은 그대로는 모델에 넣을 수 없고, 날짜 자체(2024-03-02)보다 **기간**(얼마나 다녔나, 얼마나 쉬었나)이 재등록을 설명한다. 방문횟수는 오래 다닌 회원일수록 크므로 이용 기간으로 나눈 **비율**(주당방문)이 더 공정한 비교다. 재등록한 회원의 주당방문이 눈에 띄게 많다. 이 함수는 행마다 계산하므로 `fit`이 필요 없고, `FunctionTransformer(add_features)`로 파이프라인 맨 앞에 넣는다. 기준일 `REF`를 오늘 날짜(`pd.Timestamp.today()`)로 두면 실행하는 날마다 특성이 달라져 재현되지 않는다. 기준일은 고정한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-014",
   "metadata": {},
   "source": [
    "## 문제 4. 같은 조각으로 비교 (코드)\n",
    "\n",
    "`cv_auc(models, X, y, cv)`를 쓰세요. `models`는 `{이름: 모델}` 딕셔너리입니다. 모델마다 `cross_val_score(..., scoring=\"roc_auc\")`로 조각별 AUC를 구해 `{이름: 조각별 AUC 배열}`로 돌려줍니다. 모든 모델에 인자 `cv`를 그대로 넘깁니다.\n",
    "\n",
    "아래 점검 셀이 이 함수로 세 모델(가장 많은 범주만 예측, 로지스틱 회귀, HistGradientBoosting)을 비교합니다. 둘 다 문제 2·3의 함수를 씁니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`{name: cross_val_score(m, X, y, cv=cv, scoring=\"roc_auc\") for name, m in models.items()}`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def cv_auc(models, X, y, cv):\n",
    "    return {name: cross_val_score(m, X, y, cv=cv, scoring=\"roc_auc\") for name, m in models.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "num_cols = [\"나이\", \"월회비\", \"이용주\", \"주당방문\", \"휴면일\"]\n",
    "cat_cols = [\"지점\", \"회원권\"]\n",
    "logit = Pipeline([(\"fe\", FunctionTransformer(add_features)), (\"prep\", make_prep(num_cols, cat_cols)),\n",
    "                  (\"model\", LogisticRegression(max_iter=1000))])\n",
    "tree_prep = ColumnTransformer([(\"num\", \"passthrough\", num_cols),\n",
    "                               (\"cat\", OrdinalEncoder(handle_unknown=\"use_encoded_value\", unknown_value=np.nan), cat_cols)],\n",
    "                              verbose_feature_names_out=False).set_output(transform=\"pandas\")\n",
    "hgb = Pipeline([(\"fe\", FunctionTransformer(add_features)), (\"prep\", tree_prep),\n",
    "                (\"model\", HistGradientBoostingClassifier(categorical_features=cat_cols, random_state=0))])\n",
    "models4 = {\"최빈값\": DummyClassifier(), \"로지스틱\": logit, \"HGB\": hgb}\n",
    "r4 = cv_auc(models4, Xg_dev, yg_dev, cvg)\n",
    "assert r4 is not None, \"결과를 return 하세요\"\n",
    "assert set(r4) == set(models4), f\"키가 {sorted(r4)}입니다. 모델 이름마다 하나\"\n",
    "for name, m in models4.items():\n",
    "    ref = cross_val_score(m, Xg_dev, yg_dev, cv=cvg, scoring=\"roc_auc\")\n",
    "    assert np.shape(r4[name]) == (5,), f\"{name}: 조각별 점수 5개를 배열로 돌려주세요(평균 하나가 아니라)\"\n",
    "    assert np.allclose(r4[name], ref), f\"{name}: 조각별 AUC가 기대와 다릅니다. scoring='roc_auc', cv=cv를 쓰세요\"\n",
    "other = StratifiedKFold(n_splits=3, shuffle=True, random_state=1)\n",
    "assert np.shape(cv_auc({\"로지스틱\": logit}, Xg_dev, yg_dev, other)[\"로지스틱\"]) == (3,), \"인자 cv를 그대로 쓰세요\"\n",
    "for name, s in r4.items():\n",
    "    print(f\"{name:5s} AUC {s.mean():.3f} ± {s.std(ddof=1):.3f}\")\n",
    "print(\"조각별 HGB − 로지스틱:\", (r4[\"HGB\"] - r4[\"로지스틱\"]).round(3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 가장 많은 범주만 예측하는 모델은 AUC 0.5(순위를 매기지 못함)다. 이것이 \"아무것도 배우지 않은\" 기준이다. 로지스틱 회귀와 HGB는 같은 `cvg` 조각으로 쟀으므로 조각별 차이를 비교할 수 있다. 방향뿐 아니라 차이의 **크기와 변동**을 함께 본다. 조각마다 같은 방향이고 크기가 조각 간 표준편차에 비해 뚜렷하면 운이 아닐 근거가 되고, 판단이 어려우면 반복 교차검증이나 홀드아웃으로 더 확인한다. 이 데이터에서는 다섯 조각 모두 로지스틱 회귀가 0.01~0.03 높다. 재등록 규칙이 \"주당방문이 많을수록, 휴면일이 짧을수록\"처럼 만든 특성에 대해 한 방향(선형)이고 상호작용이 없어서다. 특성 공학으로 데이터 모양을 맞춰 주면 선형 모델로 충분할 때가 있다. 트리가 늘 이기는 것은 아니므로 둘 다 같은 조각으로 재고, 비슷하거나 선형이 나으면 빠르고 설명하기 쉬운 쪽을 고른다(06·07장 기준표)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-018",
   "metadata": {},
   "source": [
    "## 문제 5. 파이프라인 안의 인자 탐색 (코드)\n",
    "\n",
    "문제 4의 `logit` 파이프라인에서 `LogisticRegression`의 `C`를 탐색합니다.\n",
    "\n",
    "1. `grid5`에 탐색 후보를 적으세요. 인자 이름은 **파이프라인 단계 이름**을 써서 정하고, 후보는 `np.logspace(-3, 2, 6)`(0.001 ~ 100)입니다.\n",
    "2. `tune(model, grid, X, y, cv)`를 쓰세요. `GridSearchCV`를 `scoring=\"roc_auc\"`, 인자 `cv`로 만들어 `X`, `y`에 `fit`한 객체를 돌려줍니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "단계 이름이 `\"model\"`이므로 `{\"model__C\": np.logspace(-3, 2, 6)}`. 이름이 헷갈리면 `[k for k in logit.get_params() if k.endswith(\"C\")]`. `tune`은 `return GridSearchCV(model, grid, cv=cv, scoring=\"roc_auc\").fit(X, y)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "grid5 = {\"model__C\": np.logspace(-3, 2, 6)}\n",
    "\n",
    "def tune(model, grid, X, y, cv):\n",
    "    return GridSearchCV(model, grid, cv=cv, scoring=\"roc_auc\").fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-020",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "assert isinstance(grid5, dict) and len(grid5) == 1, \"grid5는 {인자 이름: 후보} 딕셔너리 하나입니다\"\n",
    "key5 = next(iter(grid5))\n",
    "assert key5 in logit.get_params(), f\"'{key5}'는 logit 파이프라인의 인자 이름이 아닙니다. 단계이름__인자 꼴입니다\"\n",
    "assert key5 == \"model__C\", f\"'{key5}'는 C가 아닙니다\"\n",
    "assert np.allclose(grid5[key5], np.logspace(-3, 2, 6)), \"후보는 np.logspace(-3, 2, 6)입니다\"\n",
    "s5 = tune(logit, grid5, Xg_dev, yg_dev, cvg)\n",
    "assert s5 is not None, \"tune: 결과를 return 하세요\"\n",
    "assert isinstance(s5, GridSearchCV) and hasattr(s5, \"best_params_\"), \"fit한 GridSearchCV를 돌려주세요\"\n",
    "ref5 = GridSearchCV(logit, grid5, cv=cvg, scoring=\"roc_auc\").fit(Xg_dev, yg_dev)\n",
    "assert s5.scoring == \"roc_auc\", \"scoring='roc_auc'로 고르세요\"\n",
    "assert np.isclose(s5.best_score_, ref5.best_score_) and s5.best_params_ == ref5.best_params_, \"결과가 기대와 다릅니다. 인자 cv를 그대로 쓰세요\"\n",
    "assert hasattr(s5, \"best_estimator_\"), \"refit=True(기본값)로 두세요\"\n",
    "tab5 = pd.DataFrame(s5.cv_results_)[[\"param_model__C\", \"mean_test_score\", \"std_test_score\", \"rank_test_score\"]]\n",
    "print(tab5.round(4).to_string(index=False))\n",
    "print(\"고른 C\", s5.best_params_[\"model__C\"], \"/ 교차검증 AUC\", round(s5.best_score_, 4),\n",
    "      \"/ 홀드아웃 AUC\", round(roc_auc_score(yg_hold, s5.predict_proba(Xg_hold)[:, 1]), 4))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 파이프라인 안의 인자는 `단계이름__인자`(밑줄 두 개)로 부른다. `TransformedTargetRegressor`처럼 한 겹 더 감싸면 `regressor__model__C`처럼 길어진다(원고 9-6절). `C`는 정규화 강도의 역수라 10배 단위로 효과가 바뀌므로 로그 간격 후보를 둔다(06장). 결과 표에서 `C`가 아주 작으면 계수가 0 쪽으로 눌려 AUC가 떨어지고, 어느 정도 커지면 평평해진다. 평평한 구간에서는 차이가 표준편차보다 작아 어느 값을 골라도 비슷하다. `best_score_`는 고른 점수라 낙관적이므로 홀드아웃에서 한 번 확인한다. 같은 일을 `LogisticRegressionCV(Cs=np.logspace(-3, 2, 6), cv=cvg, scoring=\"roc_auc\")`로 할 수도 있지만, 파이프라인 끝에 넣으면 앞 단계 전처리는 그 내부 교차검증 밖에서 한 번 맞춰진다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-022",
   "metadata": {},
   "source": [
    "## 문제 6. id로 맞춘 제출 파일 (코드)\n",
    "\n",
    "`make_submission(model, test_df, sample)`를 쓰세요. `model`로 `test_df`의 재등록 **확률**(`predict_proba`의 1열)을 예측하고, 양식 `sample`과 **같은 열 이름·같은 id 순서**의 DataFrame을 돌려줍니다.\n",
    "\n",
    "- 양식의 id 순서(오름차순)는 `test_df`의 행 순서와 다릅니다.\n",
    "- id와 예측은 **같은 표(`test_df`)에서** 짝짓고, 양식의 id 순서로 맞춥니다. 행을 지우지 않습니다.\n",
    "- 양식의 열 이름(`sample.columns`)을 그대로 씁니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`pairs = pd.DataFrame({\"id\": test_df[\"id\"].to_numpy(), sample.columns[1]: model.predict_proba(test_df)[:, 1]})`, `sample[[\"id\"]].merge(pairs, on=\"id\", how=\"left\", validate=\"one_to_one\")`. 원고 9-7절과 같습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def make_submission(model, test_df, sample):\n",
    "    target = sample.columns[1]\n",
    "    pairs = pd.DataFrame({\"id\": test_df[\"id\"].to_numpy(), target: model.predict_proba(test_df)[:, 1]})\n",
    "    return sample[[\"id\"]].merge(pairs, on=\"id\", how=\"left\", validate=\"one_to_one\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "final = s5.best_estimator_\n",
    "T0 = g_test.copy()\n",
    "sub6 = make_submission(final, g_test, g_sample)\n",
    "assert sub6 is not None, \"결과를 return 하세요\"\n",
    "assert g_test.equals(T0), \"입력 표가 바뀌었습니다\"\n",
    "assert list(sub6.columns) == list(g_sample.columns), f\"열 이름이 {list(sub6.columns)}입니다. 양식과 같아야 합니다\"\n",
    "assert len(sub6) == len(g_sample), f\"행 수 {len(sub6)} ≠ {len(g_sample)}\"\n",
    "assert np.array_equal(sub6[\"id\"].to_numpy(), g_sample[\"id\"].to_numpy()), \"id 순서가 양식과 다릅니다\"\n",
    "truth = dict(zip(g_test[\"id\"], final.predict_proba(g_test)[:, 1]))\n",
    "assert np.allclose(sub6[\"재등록\"].to_numpy(), [truth[i] for i in sub6[\"id\"]]), \"id와 예측이 어긋났습니다. 같은 표에서 짝지은 뒤 id로 맞추세요\"\n",
    "assert sub6[\"재등록\"].between(0, 1).all() and not np.isin(sub6[\"재등록\"].unique(), [0, 1]).all(), \"0/1 라벨이 아니라 확률을 내세요(predict_proba)\"\n",
    "shuffled = g_test.sample(frac=1, random_state=3)                        # 행 순서가 다른 테스트 표\n",
    "assert np.allclose(make_submission(final, shuffled, g_sample)[\"재등록\"], sub6[\"재등록\"]), \"테스트 표의 행 순서가 바뀌면 결과가 달라집니다. id로 맞추세요\"\n",
    "assert sub6[\"재등록\"].notna().all(), \"빈 예측이 있습니다\"\n",
    "print(sub6.head(3).round(3).to_string(index=False))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 양식의 id 순서(오름차순)와 테스트 표의 행 순서가 다르다. `sample.copy()`에 `predict_proba(g_test)`를 그대로 붙이면 열 이름·행 수·id가 모두 양식과 같아 형식 점검을 통과하지만 예측은 다른 회원의 것이다. id와 예측을 같은 표에서 짝지은 뒤 `merge`로 양식 순서에 맞추면 테스트 표가 어떤 순서여도 결과가 같다. `validate=\"one_to_one\"`은 id 중복을 오류로 잡는다. AUC로 채점하는 대회는 0/1이 아니라 확률(또는 순위를 매길 수 있는 점수)을 제출해야 한다(05장)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-026",
   "metadata": {},
   "source": [
    "## 문제 7. 저장·재로딩 (코드)\n",
    "\n",
    "두 함수를 쓰세요.\n",
    "\n",
    "- `save_bundle(model, columns, path)`: `{\"model\": model, \"columns\": list(columns), \"sklearn\": sklearn.__version__}`를 `joblib.dump`로 `path`에 저장합니다. 돌려줄 값은 없습니다.\n",
    "- `load_predict(path, df)`: `path`를 `joblib.load`로 불러, 저장된 sklearn 버전이 지금 버전과 다르면 `ValueError`를 냅니다. 같으면 `df`에서 **저장된 열 목록만 그 순서대로** 골라 재등록 확률(1열)을 돌려줍니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`joblib.dump(bundle, path)`, `b = joblib.load(path)`, `if b[\"sklearn\"] != sklearn.__version__: raise ValueError(...)`, `b[\"model\"].predict_proba(df[b[\"columns\"]])[:, 1]`. 원고 9-8절과 같습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def save_bundle(model, columns, path):\n",
    "    joblib.dump({\"model\": model, \"columns\": list(columns), \"sklearn\": sklearn.__version__}, path)\n",
    "\n",
    "def load_predict(path, df):\n",
    "    b = joblib.load(path)\n",
    "    if b[\"sklearn\"] != sklearn.__version__:\n",
    "        raise ValueError(f\"저장 버전 {b['sklearn']} ≠ 지금 버전 {sklearn.__version__}\")\n",
    "    return b[\"model\"].predict_proba(df[b[\"columns\"]])[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "save_bundle(final, Xg.columns, \"gym_bundle.joblib\")\n",
    "b7 = joblib.load(\"gym_bundle.joblib\")\n",
    "assert isinstance(b7, dict) and set(b7) == {\"model\", \"columns\", \"sklearn\"}, \"model·columns·sklearn 세 키의 딕셔너리를 저장하세요\"\n",
    "assert b7[\"columns\"] == list(Xg.columns) and b7[\"sklearn\"] == sklearn.__version__, \"열 목록(list)과 sklearn 버전을 그대로 저장하세요\"\n",
    "p7 = load_predict(\"gym_bundle.joblib\", g_test)\n",
    "assert p7 is not None, \"load_predict: 결과를 return 하세요\"\n",
    "assert np.array_equal(p7, final.predict_proba(g_test[list(Xg.columns)])[:, 1]), \"불러온 모델의 예측이 원래 모델과 허용 오차 없이 같아야 합니다(np.array_equal)\"\n",
    "mixed = g_test[list(Xg.columns)[::-1]].assign(쓸모없는열=1)                 # 열 순서가 뒤집히고 열이 하나 더 있는 표\n",
    "assert np.array_equal(load_predict(\"gym_bundle.joblib\", mixed), p7), \"저장된 열 목록 순서대로 골라 예측하세요\"\n",
    "toy_X = pd.DataFrame({\"a\": [0.0, 1.0, 2.0, 3.0], \"b\": [1.0, 0.0, 1.0, 0.0]})\n",
    "toy = LogisticRegression().fit(toy_X, [0, 0, 1, 1])                     # 열 이름·순서를 그대로 요구하는 모델\n",
    "save_bundle(toy, [\"a\", \"b\"], \"gym_toy.joblib\")\n",
    "toy_new = pd.DataFrame({\"b\": [1.0, 0.0], \"c\": [9, 9], \"a\": [0.5, 2.5]})\n",
    "try:\n",
    "    p7t = load_predict(\"gym_toy.joblib\", toy_new)\n",
    "except ValueError as e:\n",
    "    raise AssertionError(f\"열을 고르지 않아 모델이 거부했습니다: {str(e)[:80]}. df[저장된 열 목록]으로 고르세요\")\n",
    "assert np.allclose(p7t, toy.predict_proba(toy_new[[\"a\", \"b\"]])[:, 1]), \"저장된 열 목록 순서대로 골라 예측하세요\"\n",
    "joblib.dump({**b7, \"sklearn\": \"0.0.0\"}, \"gym_old.joblib\")\n",
    "try:\n",
    "    load_predict(\"gym_old.joblib\", g_test)\n",
    "    raise AssertionError(\"버전이 다른 묶음에서 ValueError를 내야 합니다\")\n",
    "except ValueError:\n",
    "    pass\n",
    "print(\"같은 커널에서 다시 불러온 예측이 같다\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 파이프라인을 통째로 저장했으므로 특성 만들기·결측 채우기·원-핫·모델이 한 파일에 있다. 열 목록을 함께 저장해 두면 열 순서가 바뀌거나 쓸모없는 열이 더 있는 표가 와도 같은 입력을 만들 수 있다. 버전 확인은 다른 sklearn 버전에서 저장한 모델을 조용히 쓰는 일을 막는다(sklearn은 경고만 낸다). 다음 셀에서 **새 프로세스**에서도 되는지 확인한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-030",
   "metadata": {},
   "source": [
    "### 새 프로세스에서 불러오기 (실행만)\n",
    "\n",
    "아래 셀은 문제 7의 파일을 별도 파이썬 프로세스에서 불러 봅니다. `add_features`는 이 노트북(`__main__`)에서 정의했으므로 새 프로세스는 그 함수를 찾지 못합니다. 그래서 함수 코드를 `gym_features.py` 모듈로 옮기고, 그 모듈의 함수로 다시 학습·저장한 뒤 새 프로세스에서 같은 예측이 나오는지 봅니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import inspect, importlib\n",
    "script = '''import sys, joblib, numpy as np, pandas as pd\n",
    "b = joblib.load(sys.argv[1])\n",
    "test = pd.read_csv(\"gym_test.csv\")\n",
    "p = b[\"model\"].predict_proba(test[b[\"columns\"]])[:, 1]\n",
    "print(\"새 프로세스에서 같은 예측:\", np.array_equal(p, np.load(\"gym_pred.npy\")))\n",
    "'''\n",
    "open(\"gym_check.py\", \"w\", encoding=\"utf-8\").write(script)\n",
    "g_test.to_csv(\"gym_test.csv\", index=False)\n",
    "run = subprocess.run([sys.executable, \"-X\", \"utf8\", \"gym_check.py\", \"gym_bundle.joblib\"], capture_output=True, text=True, encoding=\"utf-8\")\n",
    "print(\"노트북 함수로 저장한 모델:\", (run.stderr.strip().splitlines() or [\"오류 없음\"])[-1][:100])\n",
    "\n",
    "# 함수를 모듈로 옮기고(문제 3의 코드 그대로), 모듈의 함수로 다시 만든다\n",
    "open(\"gym_features.py\", \"w\", encoding=\"utf-8\").write(f\"import pandas as pd\\n\\nREF = {REF!r}\\n\\n\\n\" + inspect.getsource(add_features))\n",
    "import gym_features\n",
    "importlib.reload(gym_features)\n",
    "from sklearn.base import clone\n",
    "final_m = clone(s5.best_estimator_).set_params(fe=FunctionTransformer(gym_features.add_features)).fit(Xg, yg)   # 3000명 전체\n",
    "np.save(\"gym_pred.npy\", final_m.predict_proba(g_test)[:, 1])\n",
    "save_bundle(final_m, Xg.columns, \"gym_bundle.joblib\")\n",
    "run = subprocess.run([sys.executable, \"-X\", \"utf8\", \"gym_check.py\", \"gym_bundle.joblib\"], capture_output=True, text=True, encoding=\"utf-8\")\n",
    "print(\"모듈 함수로 저장한 모델:\", run.stdout.strip() or run.stderr[-300:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-032",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> joblib(pickle)은 함수를 코드째 저장하지 않고 \"어느 모듈의 어떤 이름\"만 저장한다. 노트북에서 정의한 함수는 `__main__.add_features`로 저장되어, 그 이름이 없는 새 프로세스에서는 `AttributeError`가 난다. 파이프라인에 넣는 사용자 함수는 `.py` 모듈에 두고 import해 쓰고, 모델 파일과 함께 넘긴다(원고 9-8절). 마지막 학습은 고른 설정으로 정답이 있는 3000명 전체(`Xg`, `yg`)에 했다(원고 9-7절)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-033",
   "metadata": {},
   "source": [
    "## 문제 8. 탐색·제출·저장 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q8`에 적으세요.\n",
    "\n",
    "(a) `GridSearchCV`의 `best_score_`는 새 데이터에서 기대할 점수를 치우침 없이 추정한 값이다.\n",
    "(b) 하이퍼파라미터를 다 고른 뒤에는, 고른 설정으로 정답이 있는 데이터 전체에 다시 학습해 제출하는 것이 일반적이다.\n",
    "(c) 양식을 복사해 예측 열만 바꾼 제출 파일이 열 이름·행 수·id 점검을 모두 통과했다면, 행 대응도 맞다.\n",
    "(d) 같은 데이터·같은 설정이라도 `random_state=None`인 무작위 단계(예: 조기 종료의 검증 분할)가 있으면 다시 학습할 때 예측이 달라질 수 있다.\n",
    "(e) 출처를 알 수 없는 `.joblib` 모델 파일은 `joblib.load`로 열어 내용을 확인한 뒤 판단하면 안전하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-034",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q8 = \"XOXOX\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"42fc15e989da\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-036",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 여러 후보 중 가장 좋았던 점수라 낙관적이다. 홀드아웃에서 한 번 확인한다(원고 9-6절). (b) 설정은 이미 정했으니 데이터를 더 쓰는 편이 대개 낫다(원고 9-7절). (c) 문제 6·원고 9-7절의 정렬 사례처럼 형식은 맞고 예측만 다른 회원의 것일 수 있다. 행 대응은 만드는 방법(같은 표에서 짝짓고 id로 맞춤)으로 지킨다. (d) 무작위가 들어가는 단계에는 `random_state`를 고정한다(원고 9-8절). (e) `joblib.load`·`pickle.load`는 여는 순간 파일 안의 코드를 실행할 수 있다. 믿을 수 없는 파일은 열지 않는다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-037",
   "metadata": {},
   "source": [
    "## 문제 9. 검증보다 크게 낮은 제출 점수 (사례)\n",
    "\n",
    "동료가 같은 헬스장 데이터로 이렇게 했습니다.\n",
    "\n",
    "1. 훈련 데이터 전체(3000명)로 \"지점별 재등록 비율\"을 계산해 `지점비율` 열을 만들었다.\n",
    "2. 그 표로 5겹 교차검증을 해 AUC 0.95를 얻었다(지점비율 없이는 0.87).\n",
    "3. 테스트 데이터에는 훈련에서 계산한 지점별 비율을 붙여 제출했고, 제출 AUC는 0.86이었다.\n",
    "\n",
    "지점 수는 6개이고 지점마다 수백 명이 있습니다. 가장 알맞은 판단을 `q9`에 적으세요.\n",
    "\n",
    "- A. 제출 데이터가 훈련과 분포가 다른 것이 원인이다. 테스트 데이터로 다시 학습하면 된다.\n",
    "- B. 지점비율이 정답을 써서 만든 특성이라 교차검증의 검증 조각 정답이 특성에 새어 점수가 부풀었다. 이 특성은 조각마다 훈련 부분으로만 계산되게 파이프라인 안의 변환기(예: `TargetEncoder`)로 넣고 다시 비교한다. 그래도 0.87과 비슷하면 이 특성은 버린다.\n",
    "- C. 교차검증 조각 수가 적어서 생긴 운이다. 10겹으로 늘리면 0.95가 제출에서도 나온다.\n",
    "- D. HGB로 바꾸면 해결된다.\n",
    "\n",
    "※ 이 사례는 설명용 가상 숫자입니다. 지점이 적고 지점마다 표본이 많으면 실제 누수 효과는 이보다 작을 수 있고, 범주가 많고 범주마다 표본이 적을수록(예: 회원 ID, 우편번호) 커집니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-038",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-040",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 정답으로 만든 특성을 교차검증 **밖에서** 전체 데이터로 계산하면, 검증 조각 회원의 정답이 그 회원의 특성값에 들어가 있다(05장 누수). 교차검증은 부풀고, 정답이 없는 테스트에서는 그 이득이 사라진다. 범주마다 표본이 적을수록 한 회원의 정답이 비율을 크게 움직여 누수가 심해진다. 해결은 계산을 조각마다 훈련 부분으로 옮기는 것이고, sklearn `TargetEncoder`는 `fit_transform` 때 내부 교차 적합(cross fitting)으로 훈련 데이터에서도 자기 정답을 쓰지 않게 한다. A는 테스트에 정답이 없어 불가능하고, C·D는 원인(누수)을 고치지 않는다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-041",
   "metadata": {},
   "source": [
    "## 문제 10. 1·2부 상황별 선택 (사례)\n",
    "\n",
    "각 상황에 가장 알맞은 것을 고르세요. (a)~(e) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "- `B`: 평균·최빈값 예측과 선형 모델로 기준선 + 제출 파일부터\n",
    "- `L`: 정답에 로그를 씌워 학습(`TransformedTargetRegressor`), 점수는 원래 단위로\n",
    "- `G`: `GridSearchCV`·`RandomizedSearchCV`로 파이프라인 인자 탐색, 홀드아웃 한 번 확인\n",
    "- `S`: id와 예측을 같은 표에서 짝짓고 양식 id로 `merge`\n",
    "- `J`: 파이프라인 통째 + 열 목록·버전을 `joblib`으로 저장, 사용자 함수는 `.py` 모듈로\n",
    "\n",
    "(a) 4시간짜리 시험에서 표 데이터 문제를 막 받았다. 데이터를 대강 훑어봤다.\n",
    "(b) 집값 예측에서 정답 분포가 오른쪽으로 길게 늘어져 있고 RMSE가 큰 집 몇 채에 끌려간다.\n",
    "(c) 목표 변환·특성·모델을 정했고, 학습률과 잎 수만 남았다.\n",
    "(d) 테스트 표를 지역별로 정렬해 살펴본 뒤 예측을 만들었다. 양식은 id 오름차순이다.\n",
    "(e) 오늘 만든 전처리 + 모델을 내일 다른 PC의 새 노트북에서 그대로 써서 같은 예측을 내야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-042",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"BLGSJ\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch09-043",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"faab61ccb121\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-044",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 기준선과 제출 파일부터 만든다. 개선의 비교 기준이 생기고 0점을 피한다(원고 9-4절, 압축판 A절). (b) 곱으로 얽힌 값·치우친 정답은 로그로 학습하고, 지표가 원래 단위면 원래 단위로 비교한다(원고 9-5절). (c) 탐색은 마지막에, 고른 점수는 낙관적이므로 홀드아웃 한 번(원고 9-6절). (d) 정렬된 표의 예측을 양식에 그대로 붙이면 형식 점검은 통과하고 행만 어긋난다(원고 9-7절). (e) 파이프라인 통째 저장 + 사용자 함수 모듈 + 버전 고정, 새 프로세스에서 같은 예측 확인(원고 9-8절)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch09-045",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 4에서 `num_cols`의 `주당방문`·`휴면일`을 빼고(대신 `방문횟수`) 다시 비교해 특성 공학의 효과를 조각별 차이로 확인했다.\n",
    "- [ ] 문제 5의 후보를 HGB의 `model__learning_rate`·`model__max_leaf_nodes`로 바꿔 `hgb`도 탐색해 보았다.\n",
    "- [ ] 문제 6에서 `g_sample.copy()`에 예측을 그대로 붙인 제출 파일을 만들어, 형식 점검은 통과하지만 예측이 어긋나는 것을 확인했다.\n",
    "- [ ] 원고 9-10절 1·2부 기준표를 내 말로 한 번 읽었다.\n",
    "\n",
    "다음 장(10장)부터 3부 딥러닝이다. 특성을 사람이 만드는 대신 신경망이 학습하고, 그 학습이 역전파로 이루어지는 과정을 NumPy와 PyTorch로 직접 본다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
