{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch06-000",
   "metadata": {},
   "source": [
    "# 06장 실습. 선형 분류와 정규화\n",
    "\n",
    "**목표:** 로지스틱 회귀의 확률·손실·학습을 직접 계산해 sklearn과 맞추고, 결정 경계를 식으로 구한다. 정규화 강도 `C`를 교차검증으로 고르고, 정규화와 스케일링이 계수 해석에 주는 영향을 판단한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 함수 문제는 **입력 배열을 바꾸지 않고** 새 값을 돌려준다.\n",
    "- 문제 3·5는 문제 2의 함수를 쓴다. 순서대로 푼다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.special import expit\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.pipeline import make_pipeline\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",
    "# 가상의 대출 연체 데이터: 600건, 특성 20개(단위가 제각각, 쓸모 있는 것은 일부), 연체(1)가 약 20%\n",
    "Xl, yl = make_classification(n_samples=600, n_features=20, n_informative=4, n_redundant=2, weights=[0.8],\n",
    "                             class_sep=0.8, flip_y=0.03, random_state=1)\n",
    "unit = np.array([1e6, 1, 10, 100, 0.1] * 4)\n",
    "Xl = Xl * unit + 3 * unit\n",
    "Xl_tr, Xl_va, yl_tr, yl_va = train_test_split(Xl, yl, test_size=0.4, stratify=yl, random_state=0)\n",
    "sc_l = StandardScaler().fit(Xl_tr)                                 # 훈련 데이터로만 fit\n",
    "As_tr, As_va = sc_l.transform(Xl_tr), sc_l.transform(Xl_va)\n",
    "loan_model = LogisticRegression().fit(As_tr, yl_tr)\n",
    "\n",
    "print(\"대출 훈련\", Xl_tr.shape, \"검증\", Xl_va.shape, \"/ 연체 비율\", round(yl.mean(), 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-002",
   "metadata": {},
   "source": [
    "## 문제 1. 시그모이드와 로지스틱 회귀 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q1`에 적으세요. 예: `\"OXXOX\"`\n",
    "\n",
    "(a) 이진 로지스틱 회귀의 `predict_proba(X)[:, 1]`은 `decision_function(X)`에 시그모이드를 씌운 값이다.\n",
    "(b) 표준화한 특성의 계수가 0.7이면, 그 특성이 1 늘 때 1일 확률이 0.7 늘어난다.\n",
    "(c) 특성 2개 로지스틱 회귀에서 임계값을 0.5에서 0.3으로 바꾸면 결정 경계 직선의 기울기가 바뀐다.\n",
    "(d) 로그 손실은 정답 쪽 확률을 0에 가깝게 준(확신하고 틀린) 예측에 아주 큰 손실을 준다.\n",
    "(e) 특성 x₁², x₂²를 추가하면 로지스틱 회귀도 원래 평면에서 원 모양의 결정 경계를 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q1 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"5ef620cf3d04\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-005",
   "metadata": {},
   "source": [
    "## 문제 2. 넘침 없는 시그모이드 (코드)\n",
    "\n",
    "`stable_sigmoid(z)`를 쓰세요. 배열 `z`를 받아 같은 모양의 σ(z) = 1 / (1 + e^(−z))를 돌려줍니다.\n",
    "\n",
    "- `z`가 −1000처럼 아주 작아도 **넘침(overflow) 경고 없이** 계산해야 합니다. 점검 셀은 넘침을 오류로 바꿔(`np.errstate(over=\"raise\")`) 확인합니다.\n",
    "- `scipy.special.expit`은 쓰지 않습니다(정답 비교에만 씁니다).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`e = np.exp(-np.abs(z))`는 늘 0~1이라 넘치지 않습니다. z ≥ 0이면 σ = 1 / (1 + e), z < 0이면 σ = e / (1 + e)입니다(분자·분모에 e^z를 곱한 식). `np.where(z >= 0, ..., ...)`로 고릅니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def stable_sigmoid(z):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "zt = np.array([-1000.0, -30.0, -2.0, 0.0, 2.0, 30.0, 1000.0])\n",
    "z0 = zt.copy()\n",
    "with np.errstate(over=\"raise\", divide=\"raise\", invalid=\"raise\"):\n",
    "    try:\n",
    "        s2 = stable_sigmoid(zt)\n",
    "    except FloatingPointError as e:\n",
    "        raise AssertionError(f\"넘침·0 나누기가 생겼습니다({e}). np.exp에 큰 양수가 들어가지 않게 하세요\") from None\n",
    "assert s2 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(zt, z0), \"입력 배열이 바뀌었습니다\"\n",
    "assert np.shape(s2) == zt.shape, f\"모양이 {np.shape(s2)}입니다. 입력과 같아야 합니다\"\n",
    "assert np.allclose(s2, expit(zt), rtol=1e-12, atol=0), f\"{s2} ≠ expit {expit(zt)}\"\n",
    "Z2 = np.random.default_rng(2).normal(0, 20, (50, 3))\n",
    "assert np.allclose(stable_sigmoid(Z2), expit(Z2), rtol=1e-12, atol=0), \"2차원 무작위 입력에서 expit과 다릅니다\"\n",
    "print(np.round(s2, 4))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-008",
   "metadata": {},
   "source": [
    "## 문제 3. 계수로 확률 직접 계산 (코드)\n",
    "\n",
    "`proba_from_linear(X, w, b)`를 쓰세요. 특성 `X`(N, d), 계수 `w`(d,), 절편 `b`로 `predict_proba`와 같은 `(N, 2)` 배열 `[1 − p, p]`를 돌려줍니다. 문제 2의 `stable_sigmoid`를 씁니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`p = stable_sigmoid(X @ w + b)`, `np.column_stack([1 - p, p])`. 대출 모델이면 `w = loan_model.coef_[0]`, `b = loan_model.intercept_[0]`입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def proba_from_linear(X, w, b):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-010",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "r3 = proba_from_linear(np.array([[0.0, 0.0], [1.0, 2.0]]), np.array([1.0, -1.0]), 0.5)\n",
    "assert r3 is not None, \"결과를 return 하세요\"\n",
    "assert np.shape(r3) == (2, 2), f\"모양이 {np.shape(r3)}입니다. (N, 2)여야 합니다\"\n",
    "assert np.allclose(r3, [[1 - expit(0.5), expit(0.5)], [1 - expit(-0.5), expit(-0.5)]]), f\"작은 예에서 {np.round(r3, 4)}입니다. 열 순서는 [1 − p, p]\"\n",
    "A0 = As_va.copy()\n",
    "P3 = proba_from_linear(As_va, loan_model.coef_[0], loan_model.intercept_[0])\n",
    "assert np.array_equal(As_va, A0), \"입력 배열이 바뀌었습니다\"\n",
    "assert np.allclose(P3, loan_model.predict_proba(As_va)), \"대출 검증 데이터에서 predict_proba와 다릅니다\"\n",
    "z3 = loan_model.decision_function(As_va)\n",
    "print(\"처음 3건 z\", np.round(z3[:3], 3), \"→ p\", np.round(P3[:3, 1], 3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-011",
   "metadata": {},
   "source": [
    "## 문제 4. 로그 손실 직접 계산 (코드)\n",
    "\n",
    "`bce(y, p, eps=1e-15)`를 쓰세요. 정답 `y`(0/1)와 1일 확률 `p`로 평균 로그 손실 −mean[y log p + (1 − y) log(1 − p)]를 파이썬 `float`로 돌려줍니다.\n",
    "\n",
    "- `p`가 0이나 1이어도 무한대가 되지 않게, 먼저 `p`를 `[eps, 1 − eps]`로 자릅니다(`np.clip`).\n",
    "- `sklearn.metrics.log_loss`는 쓰지 않습니다(정답 비교에만 씁니다).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`q = np.clip(p, eps, 1 - eps)` 뒤 원고 6-5절의 식. 자른 값을 새 변수에 담으면 입력 `p`가 바뀌지 않습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def bce(y, p, eps=1e-15):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "r4 = bce(np.array([1, 0, 1]), np.array([0.9, 0.2, 0.6]))\n",
    "assert r4 is not None, \"결과를 return 하세요\"\n",
    "assert type(r4) is float, f\"파이썬 float로 돌려주세요(지금 {type(r4).__name__})\"\n",
    "assert np.isclose(r4, -(np.log(0.9) + np.log(0.8) + np.log(0.6)) / 3), f\"작은 예에서 {r4}입니다\"\n",
    "pe = np.array([0.0, 1.0, 1.0])\n",
    "p0 = pe.copy()\n",
    "r4e = bce(np.array([1, 1, 0]), pe)\n",
    "assert np.array_equal(pe, p0), \"입력 배열이 바뀌었습니다(np.clip 결과를 새 변수에)\"\n",
    "assert np.isfinite(r4e), \"확률 0·1에서 무한대가 나왔습니다. 먼저 자르세요\"\n",
    "assert np.isclose(r4e, -(np.log(1e-15) + np.log(1 - 1e-15) + np.log(1 - (1 - 1e-15))) / 3), f\"0·1 예에서 {r4e}입니다. eps로 잘랐나요?\"\n",
    "r4k = bce(np.array([1, 0]), np.array([0.0, 1.0]), eps=0.1)\n",
    "assert np.isclose(r4k, -np.log(0.1)), f\"eps=0.1로 불렀을 때 {r4k}입니다. 인자 eps를 그대로 쓰세요\"\n",
    "p4 = loan_model.predict_proba(As_va)[:, 1]\n",
    "assert np.isclose(bce(yl_va, p4), log_loss(yl_va, p4)), \"대출 검증 데이터에서 log_loss와 다릅니다\"\n",
    "print(\"대출 검증 로그 손실\", round(bce(yl_va, p4), 4), \"/ 모두 연체 비율로 예측하면\", round(bce(yl_va, np.full(len(yl_va), yl_tr.mean())), 4))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-014",
   "metadata": {},
   "source": [
    "## 문제 5. 경사하강법 로지스틱 회귀 + L2 (코드)\n",
    "\n",
    "`fit_logistic_l2(X, y, lam, lr=0.5, steps=3000)`을 쓰세요. 손실\n",
    "\n",
    "L(w, b) = (평균 로그 손실) + (lam / 2) · Σ wⱼ²\n",
    "\n",
    "을 경사하강법으로 줄여 `(w, b)`를 돌려줍니다. `w`는 0, `b`는 0.0에서 시작합니다.\n",
    "\n",
    "- 기울기: ∂L/∂w = Xᵀ(p − y) / N + lam · w, ∂L/∂b = mean(p − y). **절편 b에는 벌점이 없습니다.**\n",
    "- `p`는 문제 2의 `stable_sigmoid(X @ w + b)`.\n",
    "\n",
    "sklearn은 \"C × 로그 손실 합 + ½‖w‖²\"를 줄이므로, 이를 C·N으로 나누면 위 식에서 **lam = 1 / (C · N)**인 경우와 같습니다. 점검 셀은 이 관계로 sklearn과 비교합니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 6-5절 `fit_logistic`에 `+ lam * w` 한 항만 더합니다. `w -= lr * (X.T @ (p - y) / len(y) + lam * w)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def fit_logistic_l2(X, y, lam, lr=0.5, steps=3000):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "A0 = As_tr.copy()\n",
    "res5 = fit_logistic_l2(As_tr, yl_tr, 0.0)\n",
    "assert res5 is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(As_tr, A0), \"입력 배열이 바뀌었습니다\"\n",
    "w5, b5 = res5\n",
    "Xs5, ys5 = np.array([[1.0, 2.0], [-1.0, 0.0], [0.0, 1.0]]), np.array([1, 0, 1])\n",
    "w1s, b1s = fit_logistic_l2(Xs5, ys5, 0.3, lr=0.2, steps=1)            # 한 단계: p는 모두 0.5, 벌점 기울기는 0\n",
    "assert np.allclose(w1s, -0.2 * Xs5.T @ (0.5 - ys5) / 3) and np.isclose(b1s, -0.2 * np.mean(0.5 - ys5)), f\"lr=0.2, steps=1에서 ({w1s}, {b1s})입니다. 인자 lr·steps를 그대로 쓰세요\"\n",
    "w2s, _ = fit_logistic_l2(Xs5, ys5, 0.3, lr=0.2, steps=2)\n",
    "p1s = stable_sigmoid(Xs5 @ w1s + b1s)\n",
    "assert np.allclose(w2s, w1s - 0.2 * (Xs5.T @ (p1s - ys5) / 3 + 0.3 * w1s)), \"두 단계 결과가 손계산과 다릅니다. 벌점 기울기 lam·w를 확인하세요\"\n",
    "assert np.shape(w5) == (As_tr.shape[1],), f\"w 모양이 {np.shape(w5)}입니다\"\n",
    "N = len(yl_tr)\n",
    "for C in [np.inf, 1.0, 0.1, 0.01]:\n",
    "    lam = 0.0 if np.isinf(C) else 1 / (C * N)\n",
    "    w_, b_ = fit_logistic_l2(As_tr, yl_tr, lam)\n",
    "    ref = LogisticRegression(C=C, tol=1e-10, max_iter=10000).fit(As_tr, yl_tr)\n",
    "    assert np.allclose(w_, ref.coef_[0], atol=1e-4), f\"C={C}(lam={lam:.5f}): 계수가 sklearn과 다릅니다. 최대 차이 {np.abs(w_ - ref.coef_[0]).max():.4f}. 벌점 기울기 lam·w와 반복 횟수 steps를 확인하세요\"\n",
    "    assert np.isclose(b_, ref.intercept_[0], atol=1e-4), f\"C={C}: 절편이 sklearn과 다릅니다({b_:.4f} ≠ {ref.intercept_[0]:.4f}). 절편에는 벌점을 주지 않습니다\"\n",
    "    print(f\"C {C:>5}: |w|합 {np.abs(w_).sum():.3f}, 절편 {b_:+.3f}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-017",
   "metadata": {},
   "source": [
    "## 문제 6. 임계값별 결정 경계 (코드)\n",
    "\n",
    "특성 2개 로지스틱 회귀(계수 `w = [w1, w2]`, 절편 `b`)에서 임계값 `t`의 결정 경계는 w1·x1 + w2·x2 + b = logit(t)인 직선입니다. `boundary_x2(w, b, x1, t)`를 쓰세요. 배열 `x1`의 각 값에 대해 경계 위의 `x2`를 돌려줍니다(`w2`는 0이 아니라고 가정).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "logit(t) = log(t / (1 − t)). 식을 x2에 대해 풀면 x2 = (logit(t) − b − w1·x1) / w2.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def boundary_x2(w, b, x1, t):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "x1s = np.linspace(-3, 3, 7)\n",
    "r6 = boundary_x2(np.array([2.0, -1.0]), 0.5, x1s, 0.5)\n",
    "assert r6 is not None, \"결과를 return 하세요\"\n",
    "assert np.allclose(r6, 2 * x1s + 0.5), f\"작은 예(t=0.5)에서 {r6}입니다\"\n",
    "m2 = LogisticRegression().fit(As_tr[:, :2], yl_tr)\n",
    "w6, b6 = m2.coef_[0], m2.intercept_[0]\n",
    "for t in [0.2, 0.5, 0.8]:\n",
    "    x2s = boundary_x2(w6, b6, x1s, t)\n",
    "    pts = np.column_stack([x1s, x2s])\n",
    "    assert np.allclose(m2.predict_proba(pts)[:, 1], t), f\"t={t}: 경계 위의 점인데 모델 확률이 {np.round(m2.predict_proba(pts)[:, 1], 3)}입니다\"\n",
    "slopes = [np.polyfit(x1s, boundary_x2(w6, b6, x1s, t), 1)[0] for t in [0.2, 0.5, 0.8]]\n",
    "assert np.allclose(slopes, slopes[0]), \"임계값이 달라도 기울기는 같아야 합니다\"\n",
    "fig, ax = plt.subplots(figsize=(4.5, 3.5))\n",
    "ax.scatter(As_va[:, 0], As_va[:, 1], c=yl_va, cmap=\"coolwarm\", s=10)\n",
    "for t, ls in [(0.2, \":\"), (0.5, \"-\"), (0.8, \"--\")]:\n",
    "    ax.plot(x1s, boundary_x2(w6, b6, x1s, t), \"k\", ls=ls, label=f\"t={t}\")\n",
    "ax.set_xlim(-3, 3); ax.set_ylim(-3, 3); ax.legend(); ax.set_title(\"특성 2개만 쓴 대출 모델의 경계\")\n",
    "plt.show()\n",
    "print(\"기울기\", round(slopes[0], 3))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-020",
   "metadata": {},
   "source": [
    "## 문제 7. 교차검증으로 C 고르기 (코드)\n",
    "\n",
    "`cv_log_loss_by_C(X, y, Cs, cv)`를 쓰세요. `Cs`의 각 `C`마다 `make_pipeline(StandardScaler(), LogisticRegression(C=C))`의 교차검증 **평균 로그 손실**(양수)을 구해 `{C: 평균 로그 손실}` 딕셔너리로 돌려줍니다. 분할은 인자로 받은 `cv`를 그대로 씁니다. 그다음 `pick_C(table)`로 평균 로그 손실이 가장 작은 `C`를 돌려줍니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`cross_val_score(pipe, X, y, cv=cv, scoring=\"neg_log_loss\")`는 **음수** 로그 손실을 줍니다(클수록 좋게 통일, 05장). 부호를 바꿔 평균합니다. `pick_C`는 `min(table, key=table.get)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def cv_log_loss_by_C(X, y, Cs, cv):\n",
    "    pass   # 작성\n",
    "\n",
    "def pick_C(table):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-022",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "Cs = [0.001, 0.01, 0.1, 1, 10, 100]\n",
    "cv7 = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)\n",
    "X0 = Xl_tr.copy()\n",
    "tab7 = cv_log_loss_by_C(Xl_tr, yl_tr, Cs, cv7)\n",
    "assert tab7 is not None, \"cv_log_loss_by_C: 결과를 return 하세요\"\n",
    "assert np.array_equal(Xl_tr, X0), \"입력 배열이 바뀌었습니다\"\n",
    "assert set(tab7) == set(Cs), f\"키가 {sorted(tab7)}입니다. C마다 하나씩\"\n",
    "assert all(v > 0 for v in tab7.values()), \"로그 손실은 양수입니다. neg_log_loss의 부호를 바꾸세요\"\n",
    "for C in Cs:\n",
    "    ref = -cross_val_score(make_pipeline(StandardScaler(), LogisticRegression(C=C)), Xl_tr, yl_tr, cv=cv7, scoring=\"neg_log_loss\").mean()\n",
    "    leak = -cross_val_score(LogisticRegression(C=C), StandardScaler().fit_transform(Xl_tr), yl_tr, cv=cv7, scoring=\"neg_log_loss\").mean()\n",
    "    assert not np.isclose(tab7[C], leak, rtol=0, atol=1e-12) or np.isclose(ref, leak, rtol=0, atol=1e-12), f\"C={C}: 스케일러를 전체 데이터로 fit한 것 같습니다. 파이프라인 안에 넣으세요\"\n",
    "    assert np.isclose(tab7[C], ref, rtol=0, atol=1e-9), f\"C={C}: {tab7[C]:.4f} ≠ 기대 {ref:.4f}\"\n",
    "    print(f\"C {C:>6}: {tab7[C]:.4f}\")\n",
    "cv7b = StratifiedKFold(n_splits=3, shuffle=True, random_state=7)\n",
    "tab7b = cv_log_loss_by_C(Xl_tr, yl_tr, [1], cv7b)\n",
    "ref7b = -cross_val_score(make_pipeline(StandardScaler(), LogisticRegression(C=1)), Xl_tr, yl_tr, cv=cv7b, scoring=\"neg_log_loss\").mean()\n",
    "assert np.isclose(tab7b[1], ref7b, rtol=0, atol=1e-9), \"다른 cv를 넘겼을 때 결과가 다릅니다. 인자 cv를 그대로 쓰세요\"\n",
    "assert pick_C({0.1: 0.5, 1: 0.3, 10: 0.4}) == 1, \"평균 로그 손실이 가장 작은 C입니다\"\n",
    "best7 = pick_C(tab7)\n",
    "assert best7 == min(Cs, key=lambda c: tab7[c]), f\"pick_C가 {best7}입니다\"\n",
    "print(\"교차검증으로 고른 C\", best7)\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-023",
   "metadata": {},
   "source": [
    "## 문제 8. 정규화와 스케일링 참/거짓 (개념)\n",
    "\n",
    "맞으면 `O`, 틀리면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q8`에 적으세요.\n",
    "\n",
    "(a) `LogisticRegression`의 `C`를 키우면 정규화가 강해진다.\n",
    "(b) L1 정규화는 일부 계수를 정확히 0으로 만들 수 있어 특성 선택에 쓰인다.\n",
    "(c) `Ridge`의 `alpha`와 `LogisticRegression`의 `C`는 둘 다 클수록 정규화가 강하다.\n",
    "(d) 정규화를 쓰는 선형 모델에서는 스케일링 없이 특성 하나의 단위만 바꿔도 예측이 달라질 수 있다.\n",
    "(e) `ConvergenceWarning`이 나면 가장 먼저 `max_iter`를 키운다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q8 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"42fc15e989da\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-026",
   "metadata": {},
   "source": [
    "## 문제 9. 계수 해석이 이상한 대출 모델 (사례)\n",
    "\n",
    "대출 팀이 연체 예측 모델을 `LogisticRegression()`(기본값 `C=1.0`)으로, **표준화 없이** 원 단위 그대로 학습했습니다. 특성에는 \"연소득(원)\", \"보유 카드 수(장)\", \"최근 연체 횟수(회)\" 등이 있습니다. 학습 결과 연소득의 계수는 0.0000002로 거의 0이고, 보유 카드 수의 계수는 0.4였습니다. 팀장이 \"연소득은 연체와 거의 무관하니 다음 버전에서 빼자\"고 합니다. 가장 알맞은 판단을 `q9`에 적으세요.\n",
    "\n",
    "- A. 맞다. 계수가 0에 가까우면 그 특성은 쓸모없으므로 빼도 된다.\n",
    "- B. 아직 판단할 수 없다. 계수 크기는 특성의 단위에 달려 있고(연소득은 1원 단위라 값이 수천만), 기본 L2 벌점도 단위를 탄다. 표준화한 뒤(파이프라인) 다시 학습해 계수를 비교하고, 연소득을 뺀 모델과 넣은 모델을 교차검증 점수로 비교해 정한다.\n",
    "- C. `C=np.inf`로 정규화만 끄면 지금 계수 크기를 그대로 비교할 수 있다.\n",
    "- D. 검증 정확도가 높으므로 계수 해석도 믿을 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-029",
   "metadata": {},
   "source": [
    "## 문제 10. 상황별 선택 (사례)\n",
    "\n",
    "각 상황에 가장 알맞은 것을 고르세요. (a)~(e) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "- `B`: 표준화 + 로지스틱 회귀(기본 L2)로 기준선\n",
    "- `L`: L1 정규화 로지스틱 회귀(`l1_ratio=1`)\n",
    "- `Q`: 제곱·곱 특성 추가 + 정규화\n",
    "- `S`: `C`를 더 작게\n",
    "- `G`: `C`를 더 크게\n",
    "\n",
    "(a) 스팸 분류. 단어 5000개가 특성이고 메일은 2000통이다. 어떤 단어가 판단에 쓰였는지 짧은 목록으로 보고해야 한다.\n",
    "(b) 처음 받은 표 데이터 분류 과제. 아직 아무 모델도 돌려 보지 않았다.\n",
    "(c) 특성 2개짜리 센서 데이터. 산점도를 그려 보니 한 범주가 다른 범주를 고리 모양으로 둘러싸고 있다.\n",
    "(d) `C=100`에서 훈련 로그 손실 0.01, 검증 로그 손실 0.7이다.\n",
    "(e) `C=0.0001`에서 훈련·검증 로그 손실이 모두 기준선(연체 비율로만 예측)과 거의 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"2313e1645530\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-032",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 2에서 `1 / (1 + np.exp(-z))`로 바꿔 넘침 경고가 어떻게 나오는지 확인했다.\n",
    "- [ ] 문제 5에서 `steps`를 300으로 줄여 sklearn과 얼마나 달라지는지 확인했다.\n",
    "- [ ] 문제 7에서 고른 `C`로 `Xl_tr` 전체에 다시 학습하고, `Xl_va`의 로그 손실을 **한 번만** 재 봤다.\n",
    "- [ ] 원고 6-11절 선택 기준표의 네 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(07장)에서는 특성을 직접 만들지 않아도 휘어진 경계를 찾는 결정 트리와 앙상블을 다룬다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
