{
 "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 = \"OXXOO\""
   ]
  },
  {
   "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": [
    "> **해설**\n",
    ">\n",
    "> (a) 로지스틱 회귀 = 선형 점수 z + 시그모이드(원고 6-3절). (b) 계수는 **로그 오즈**의 변화다. 오즈가 e^0.7 ≈ 2.0배가 되고, 확률이 늘어나는 양은 출발 확률에 따라 다르다. (c) p ≥ t ⇔ z ≥ logit(t)이므로 상수만 바뀌고 기울기 w는 그대로다. 경계는 평행 이동한다. (d) 정답 1에 p = 0.01이면 −log 0.01 ≈ 4.6이다. (e) 모델은 새 특성에 대해 선형이고, 원래 평면에서는 z = 상수가 원(또는 타원)이 된다(원고 6-4절)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-006",
   "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-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def stable_sigmoid(z):\n",
    "    e = np.exp(-np.abs(z))\n",
    "    return np.where(z >= 0, 1 / (1 + e), e / (1 + e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-008",
   "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-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `1 / (1 + np.exp(-z))`는 z = −1000에서 `np.exp(1000)`이 float64 최댓값(약 1.8 × 10³⁰⁸)을 넘어 `inf`가 되고 경고가 난다. 결과는 1/inf = 0으로 맞게 나오지만, 경고가 쌓이고 다른 식(예: 로그 손실의 `log(1 − p)`)과 섞이면 `nan`·`-inf`가 생긴다. e^(−|z|)만 계산하면 지수에 늘 0 이하가 들어가 안전하다. `np.where`는 두 식을 모두 계산하지만 두 식 모두 e만 쓰므로 문제없다. 실무에서는 `scipy.special.expit`, PyTorch에서는 `torch.sigmoid`가 이렇게 처리한다. 더 나아가 손실까지 한 번에 안정하게 계산하는 함수(PyTorch `BCEWithLogitsLoss`)를 11장에서 쓴다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-010",
   "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-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def proba_from_linear(X, w, b):\n",
    "    p = stable_sigmoid(X @ w + b)\n",
    "    return np.column_stack([1 - p, p])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-012",
   "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-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> sklearn 이진 로지스틱 회귀의 `predict_proba`는 정확히 이 계산이다. 첫 열은 `classes_[0]`(여기서 0) 확률, 둘째 열은 `classes_[1]` 확률이다. 계수와 절편만 있으면 sklearn 없이도 예측할 수 있으므로, 학습한 모델을 다른 시스템(예: SQL, 엑셀)에 옮길 때 이 식을 쓰기도 한다. 이때 학습에 쓴 **표준화도 같은 평균·표준편차로** 똑같이 옮겨야 한다. 여기서 `As_va`는 이미 `sc_l`로 변환한 값이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-014",
   "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-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def bce(y, p, eps=1e-15):\n",
    "    q = np.clip(p, eps, 1 - eps)\n",
    "    return float(-np.mean(y * np.log(q) + (1 - y) * np.log(1 - q)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-016",
   "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-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 마지막 줄의 두 번째 값은 특성을 전혀 안 쓰고 모든 사람에게 \"훈련 데이터의 연체 비율\"을 확률로 준 **기준선**의 로그 손실이다. 로그 손실은 단독으로는 크기를 읽기 어려우므로 이런 기준선과 비교한다(05장의 \"모두 0\" 정확도 기준선과 같은 생각). 자르기 값 `eps`가 결과를 좌우할 만큼 크게 틀린 예측이 있다면, 그 자체가 모델이 지나치게 확신한다는 신호다. sklearn `log_loss`도 내부에서 확률을 아주 작은 값 안쪽으로 자르지만 그 값은 버전에 따라 다를 수 있어서, 점검은 확률이 0·1이 아닌 경우만 sklearn과 비교했다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-018",
   "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-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def fit_logistic_l2(X, y, lam, lr=0.5, steps=3000):\n",
    "    w, b = np.zeros(X.shape[1]), 0.0\n",
    "    for _ in range(steps):\n",
    "        p = stable_sigmoid(X @ w + b)\n",
    "        w = w - lr * (X.T @ (p - y) / len(y) + lam * w)\n",
    "        b = b - lr * np.mean(p - y)\n",
    "    return w, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-020",
   "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-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `C`가 작을수록(lam이 클수록) 계수 크기의 합이 줄어든다. 벌점의 기울기 lam · w는 계수를 매 단계 자기 크기에 비례해 0 쪽으로 당기므로, L2는 계수를 \"고르게 줄이되 정확히 0으로는 잘 만들지 않는다\". 신경망에서 같은 항을 **가중치 감쇠**(weight decay)라 부른다(11장). sklearn의 `C`가 \"로그 손실 **합**\"에 곱해진다는 점도 기억할 것: 같은 `C`라도 훈련 데이터가 많아지면 lam = 1/(C·N)이 작아져 정규화 효과가 약해진다. 데이터 양이 바뀌면 `C`를 다시 고른다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-022",
   "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-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def boundary_x2(w, b, x1, t):\n",
    "    return (np.log(t / (1 - t)) - b - w[0] * x1) / w[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-024",
   "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-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 경계 위의 점에서는 z = logit(t)이므로 모델 확률이 정확히 t다. 세 직선의 기울기는 −w1/w2로 같고 절편만 다르다. 임계값을 낮추면 1 영역이 넓어진다. 이 그림에서 두 범주가 많이 겹치는 것은 특성 20개 중 2개만 썼기 때문이다. 특성이 d개면 경계는 d차원 공간의 초평면이고 그림으로 그릴 수 없지만, \"z = logit(t)인 평평한 면\"이라는 성질은 같다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-026",
   "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-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def cv_log_loss_by_C(X, y, Cs, cv):\n",
    "    out = {}\n",
    "    for C in Cs:\n",
    "        pipe = make_pipeline(StandardScaler(), LogisticRegression(C=C))\n",
    "        out[C] = float(-cross_val_score(pipe, X, y, cv=cv, scoring=\"neg_log_loss\").mean())\n",
    "    return out\n",
    "\n",
    "def pick_C(table):\n",
    "    return min(table, key=table.get)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-028",
   "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-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `C`가 아주 작으면(0.001) 계수가 눌려 연체 비율 기준선에 가깝고, 0.1 근처에서 가장 좋으며, 더 키우면 조금씩 나빠진다. 이 데이터는 특성 20개 중 쓸모 있는 것이 일부라 정규화가 도움이 된다. 고른 `C`로 훈련 데이터 전체에 다시 학습한 뒤, 마지막 성능은 따로 둔 데이터(여기서는 `Xl_va`)로 한 번만 잰다. 점검 셀은 스케일러를 전체 데이터로 `fit`한 계산(누수)과도 비교한다. 이 데이터에서 누수 차이는 작지만, 05장처럼 습관으로 파이프라인에 넣는다. 같은 일을 하는 `LogisticRegressionCV`, 여러 하이퍼파라미터를 한 번에 찾는 `GridSearchCV`는 9장에서 쓴다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-030",
   "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-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q8 = \"XOXOX\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"42fc15e989da\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) `C`는 강도의 **역수**다. 키우면 약해진다. (b) 절댓값 벌점은 0에서 꺾여 있어 작은 계수를 정확히 0으로 보낸다(원고 6-7절). (c) `alpha`는 클수록, `C`는 작을수록 강하다. 방향이 반대라 자주 틀린다. (d) 단위가 바뀌면 같은 효과를 내는 계수 크기가 바뀌고, 벌점도 바뀐다(원고 6-8절). 표준화하면 사라진다. (e) 먼저 스케일링을 확인한다. 스케일링 없이 `max_iter`만 키우면 수렴은 해도 위 (d)의 문제가 남는다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-034",
   "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-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 연소득이 1원 늘 때의 효과는 당연히 아주 작다. 계수 0.0000002에 연소득의 표준편차(예: 2000만 원)를 곱하면 4로, 표준편차 1만큼의 효과는 오히려 클 수 있다. 그래서 단위가 다른 특성의 계수는 표준화한 뒤에 비교한다. 정규화를 끄면(C) 벌점 문제는 없어지지만 단위 문제는 그대로이고, 특성끼리 얽혀 있으면 계수 해석은 여전히 불안정하다. 정확도(D)는 예측이 맞는지를 말할 뿐 계수의 의미를 보증하지 않는다. 특성을 뺄지 말지는 결국 \"빼고 학습한 모델이 교차검증에서 나빠지는가\"로 정하는 것이 가장 확실하다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-038",
   "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-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"LBQSG\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch06-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"2313e1645530\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-041",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 특성이 표본보다 많고 쓸모 있는 단어는 일부이며, 짧은 목록이 필요하므로 L1. 얽힌 단어 중 어느 것이 남는지는 우연일 수 있다는 점을 보고에 함께 적는다. (b) 먼저 기준선을 세운다(원고 6-11절). (c) 경계가 원 모양이므로 직선 경계로는 못 나눈다. 제곱 특성을 더하거나, 7장 트리·10장 신경망을 쓴다. (d) 훈련·검증 차이가 크다: 과적합이므로 정규화를 강하게(C를 작게). (e) 둘 다 기준선 수준: 과소적합이므로 정규화를 약하게(C를 크게). 어느 쪽이든 최종 `C`는 로그 간격 후보를 교차검증으로 고른다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch06-042",
   "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
}
