{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch01-000",
   "metadata": {},
   "source": [
    "# 01장 실습. AI의 흐름\n",
    "\n",
    "**목표:** 흐름의 전환점과 학습 방식을 구분하고, 같은 문제를 사람이 쓴 규칙과 머신러닝으로 풀어 비교한다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib\n",
    "import numpy as np\n",
    "from sklearn.datasets import load_iris, load_digits\n",
    "from sklearn.model_selection import train_test_split\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",
    "iris = load_iris()\n",
    "X_tr, X_te, y_tr, y_te = train_test_split(iris.data, iris.target, test_size=0.3,\n",
    "                                          random_state=0, stratify=iris.target)\n",
    "print(\"붓꽃 훈련/테스트:\", X_tr.shape, X_te.shape, list(iris.target_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-002",
   "metadata": {},
   "source": [
    "## 문제 1. 포함 관계 (개념)\n",
    "\n",
    "AI·머신러닝·딥러닝·규칙 기반 시스템의 관계로 **옳은 것**을 `q1`에 적으세요.\n",
    "\n",
    "- A. 머신러닝 ⊃ AI ⊃ 딥러닝이다.\n",
    "- B. 규칙 기반 시스템은 데이터를 쓰지 않으므로 AI가 아니다.\n",
    "- C. AI ⊃ 머신러닝 ⊃ 딥러닝이고, 규칙 기반 시스템은 AI이지만 머신러닝은 아니다.\n",
    "- D. LLM은 트랜스포머를 쓰므로 딥러닝이 아니라 별도 분야다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q1 = \"C\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"6b23c0d5f35d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-005",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 머신러닝은 AI 가운데 \"규칙을 데이터에서 배우는\" 방법이고, 딥러닝은 그중 여러 층 신경망으로 특성까지 배우는 방법이다. 사람이 규칙을 쓰는 전문가 시스템도 AI다. LLM은 트랜스포머 신경망이므로 딥러닝·머신러닝·AI 모두에 속한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-006",
   "metadata": {},
   "source": [
    "## 문제 2. 막힌 것과 푼 것 (개념)\n",
    "\n",
    "아래 (1)~(4)는 각 시기에 **막힌 것**입니다. 그것을 푼 다음 단계를 보기에서 골라, (1)(2)(3)(4) 순서대로 이어 쓴 문자열을 `q2`에 적으세요. 예: `\"ABCD\"`\n",
    "\n",
    "(1) 단어를 하나씩 순서대로 계산해 긴 문장에 약하고 병렬 학습이 어렵다.\n",
    "(2) 전문가의 판단을 규칙으로 옮기기 어렵고, 예외마다 규칙을 덧붙이다 충돌한다.\n",
    "(3) 과제마다 라벨 데이터를 많이 모아 따로 학습해야 한다.\n",
    "(4) 사진의 픽셀에서 좋은 특성을 사람이 직접 설계해야 한다.\n",
    "\n",
    "보기\n",
    "\n",
    "- A. 머신러닝: 정답 달린 예시에서 규칙을 찾는다.\n",
    "- B. 딥러닝: 여러 층 신경망이 원시 입력에서 특성까지 배운다.\n",
    "- C. 트랜스포머: 어텐션으로 모든 위치를 한꺼번에 비교한다.\n",
    "- D. 자기지도 사전학습: 라벨 없는 대량 데이터로 먼저 배우고 적은 라벨로 맞춘다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "원고 1-4절에서 각 단계의 \"막힌 것\"이 바로 다음 단계의 \"푼 것\"이 됩니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q2 = \"CADB\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-008",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q2\", q2, \"ab2609f3e8c0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (1) RNN의 순차 계산 → 트랜스포머(C). (2) 지식 획득 병목·규칙 충돌 → 머신러닝(A). (3) 과제별 라벨 → 자기지도 사전학습 후 미세조정(D). (4) 특성 공학 → 딥러닝(B). 각 방법은 앞 방법의 한계를 메우려고 나왔다. 반대로 앞 방법으로 충분한 문제에는 뒤 방법이 과할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-010",
   "metadata": {},
   "source": [
    "## 문제 3. 학습 방식 고르기 (개념)\n",
    "\n",
    "각 과제의 학습 방식을 기호로 골라 (a)~(e) 순서대로 이어 쓴 문자열을 `q3`에 적으세요.\n",
    "\n",
    "- `R` 지도 학습-회귀, `C` 지도 학습-분류, `U` 비지도 학습, `S` 자기지도 학습\n",
    "\n",
    "(a) 면적·층수·역까지 거리로 아파트 가격(원)을 예측한다.\n",
    "(b) 라벨 없는 뉴스 기사 1만 건을 비슷한 주제끼리 묶는다.\n",
    "(c) 문장의 일부 단어를 가리고 가린 단어를 맞히게 해서 언어 모델을 사전학습한다.\n",
    "(d) 과거에 사람이 스팸/정상으로 표시한 메일로, 새 메일이 스팸인지 판단한다.\n",
    "(e) 지난 기상 기록으로 내일 최고 기온(℃)을 예측한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q3 = \"RUSCR\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q3\", q3, \"d0edeed10c70\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 정답이 있으면 지도 학습이고, 정답이 숫자 크기면 회귀(a, e), 범주면 분류(d)다. 정답이 아예 없으면 비지도(b). (c)는 사람이 라벨을 달지 않았지만 가려진 원래 단어가 정답 역할을 한다. 정답을 데이터 자신에서 만들기 때문에 자기지도다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-014",
   "metadata": {},
   "source": [
    "## 문제 4. 자기지도 학습 쌍 만들기 (코드)\n",
    "\n",
    "단어 리스트 `words`와 문맥 길이 `k`를 받아 `(앞 k개 단어의 튜플, 다음 단어)` 쌍의 리스트를 돌려주는 `next_word_pairs(words, k)`를 완성하세요. 단어가 `k`개 이하이면 빈 리스트입니다.\n",
    "\n",
    "```\n",
    "next_word_pairs([\"a\", \"b\", \"c\", \"d\"], 2)\n",
    "→ [((\"a\", \"b\"), \"c\"), ((\"b\", \"c\"), \"d\")]\n",
    "```\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "다음 단어의 위치 `i`는 `k`부터 `len(words) - 1`까지입니다. 그 앞 `k`개는 `words[i - k:i]`입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def next_word_pairs(words, k):\n",
    "    return [(tuple(words[i - k:i]), words[i]) for i in range(k, len(words))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "assert next_word_pairs([\"a\", \"b\", \"c\", \"d\"], 2) == [((\"a\", \"b\"), \"c\"), ((\"b\", \"c\"), \"d\")], \"예시와 결과가 다릅니다. 마지막 단어까지 포함했나요?\"\n",
    "assert next_word_pairs([\"a\", \"b\"], 2) == [], \"단어가 k개 이하이면 빈 리스트\"\n",
    "assert next_word_pairs([\"a\"], 3) == [], \"단어가 k개보다 적어도 빈 리스트\"\n",
    "assert next_word_pairs([\"x\", \"y\", \"z\"], 1) == [((\"x\",), \"y\"), ((\"y\",), \"z\")], \"문맥은 길이 1이어도 튜플\"\n",
    "words = \"라벨 없는 글 에서 정답 을 만든다\".split()\n",
    "pairs = next_word_pairs(words, 3)\n",
    "assert pairs == [((\"라벨\", \"없는\", \"글\"), \"에서\"), ((\"없는\", \"글\", \"에서\"), \"정답\"),\n",
    "                 ((\"글\", \"에서\", \"정답\"), \"을\"), ((\"에서\", \"정답\", \"을\"), \"만든다\")], \"k=3이면 문맥이 단어 3개여야 합니다\"\n",
    "for c, t in pairs:\n",
    "    print(c, \"→\", t)\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 문장 하나(단어 n개)에서 쌍 n−k개가 사람의 라벨 없이 나온다. 글이 많을수록 학습 예시가 늘어난다. BERT식 \"가린 단어 맞히기\"도 같은 생각이다. `words[i]`를 `[MASK]`로 바꾼 문장이 입력, 원래 `words[i]`가 정답이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-018",
   "metadata": {},
   "source": [
    "## 문제 5. 붓꽃 규칙 분류기 (코드)\n",
    "\n",
    "사람이 규칙을 쓰는 방식으로 붓꽃 품종을 맞혀 봅니다.\n",
    "\n",
    "(a) 먼저 아래 셀을 실행해 **훈련 데이터**에서 품종별 특성 범위를 보세요. 테스트 데이터는 보지 않습니다.\n",
    "\n",
    "(b) 표본 하나 `x`(특성 4개)를 받아 품종 번호 0·1·2를 돌려주는 `rule_iris(x)`를 `if` 문으로 쓰세요. sklearn 모델은 쓰지 않습니다.\n",
    "\n",
    "점검 셀은 먼저 **훈련 정확도**(0.9 이상)를 보고, 넘으면 그때 테스트 정확도(0.9 이상)를 한 번 잽니다. 기준을 고칠 때는 훈련 정확도와 위의 범위만 보고 고칩니다. 테스트 점수를 보며 기준을 바꾸면 테스트가 \"처음 보는 데이터\"가 아니게 됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "for k, name in enumerate(iris.target_names):\n",
    "    part = X_tr[y_tr == k]\n",
    "    print(f\"{k} {name:<11}\", \" \".join(f\"{f[:12]:>12} {part[:, j].min():.1f}~{part[:, j].max():.1f}\"\n",
    "                                       for j, f in enumerate(iris.feature_names)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-020",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def rule_iris(x):\n",
    "    # x[0] 꽃받침 길이, x[1] 꽃받침 너비, x[2] 꽃잎 길이, x[3] 꽃잎 너비\n",
    "    if x[2] < 2.5:\n",
    "        return 0\n",
    "    if x[3] < 1.75:\n",
    "        return 1\n",
    "    return 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "pred_tr = np.array([rule_iris(x) for x in X_tr])\n",
    "assert set(pred_tr.tolist()) <= {0, 1, 2}, \"품종 번호 0·1·2를 돌려주세요\"\n",
    "assert len(set(pred_tr.tolist())) == 3, \"세 품종을 모두 예측해야 합니다\"\n",
    "train_acc = (pred_tr == y_tr).mean()\n",
    "print(\"규칙 훈련 정확도:\", round(train_acc, 3))\n",
    "assert train_acc >= 0.9, \"훈련 정확도가 0.9 미만입니다. 위의 범위에서 versicolor와 virginica가 어디서 갈리는지 다시 보세요\"\n",
    "pred_rule = np.array([rule_iris(x) for x in X_te])\n",
    "rule_acc = (pred_rule == y_te).mean()\n",
    "print(\"규칙 테스트 정확도:\", round(rule_acc, 3))\n",
    "assert rule_acc >= 0.9, \"훈련에서는 맞았지만 테스트에서 0.9 미만입니다. 기준이 훈련 데이터의 끝값에 너무 딱 맞춰져 있지 않은지 보세요\"\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-022",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> setosa는 꽃잎 길이(또는 너비) 하나로 완전히 갈린다. versicolor와 virginica는 꽃잎 너비 1.5~1.8에서 겹치므로 그 사이 어딘가를 기준으로 잡으면 대부분 맞는다. 기준값은 훈련 데이터만 보고 정했다. 테스트 데이터를 보고 기준을 고르면 테스트 점수가 실제 실력보다 좋게 나온다(5장 데이터 누수)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-023",
   "metadata": {},
   "source": [
    "## 문제 6. 결정 트리로 같은 문제 (코드)\n",
    "\n",
    "`DecisionTreeClassifier(max_depth=2, random_state=0)`를 훈련 데이터로 학습해 `tree`에 담고, 테스트 정확도를 `tree_acc`에 저장하세요.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`.fit(X_tr, y_tr)`로 학습하고 `.score(X_te, y_te)`가 정확도를 돌려줍니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "from sklearn.tree import DecisionTreeClassifier, export_text\n",
    "\n",
    "tree = DecisionTreeClassifier(max_depth=2, random_state=0).fit(X_tr, y_tr)\n",
    "tree_acc = tree.score(X_te, y_te)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "assert isinstance(tree, DecisionTreeClassifier) and hasattr(tree, \"tree_\"), \"학습한 결정 트리를 담으세요\"\n",
    "params = tree.get_params()\n",
    "assert params[\"max_depth\"] == 2 and params[\"random_state\"] == 0, \"max_depth=2, random_state=0으로 만드세요\"\n",
    "ref = DecisionTreeClassifier(max_depth=2, random_state=0).fit(X_tr, y_tr)\n",
    "assert (tree.tree_.feature == ref.tree_.feature).all() and np.allclose(tree.tree_.threshold, ref.tree_.threshold)     and np.allclose(tree.tree_.value, ref.tree_.value), \"훈련 데이터(X_tr, y_tr)로 학습하세요\"\n",
    "assert tree_acc is not None, \"테스트 정확도를 저장하세요\"\n",
    "assert abs(tree_acc - tree.score(X_te, y_te)) < 1e-12, \"테스트 데이터 정확도를 저장하세요\"\n",
    "print(f\"트리 테스트 정확도 {tree_acc:.3f} (문제 5 규칙과 비교해 보세요)\")\n",
    "print(export_text(tree, feature_names=iris.feature_names))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-026",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 트리는 꽃잎 너비 0.8과 1.75를 기준으로 골랐다. 사람이 범위를 보고 정한 규칙과 거의 같고 정확도도 비슷하다. 머신러닝은 \"범위를 보고 기준값을 정하는 일\"을 자동화한 것이다. 특성이 적고 기준이 분명하면 규칙도 충분하다. 그때는 설명하기 쉬운 쪽을 고른다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-027",
   "metadata": {},
   "source": [
    "## 문제 7. 손글씨 0과 1 (코드)\n",
    "\n",
    "8×8 손글씨 이미지(값 0~16, 클수록 진함)에서 0과 1만 골랐습니다. 0은 가운데가 비고, 1은 가운데에 세로획이 있습니다.\n",
    "\n",
    "`rule_01(img)`를 완성하세요. 이미지 하나(8×8 배열)를 받아 1이라고 판단하면 `1`, 아니면 `0`을 돌려줍니다. 기준값은 아래 셀이 출력하는 **훈련 데이터** 분포를 보고 정합니다. 문제 5처럼 훈련 정확도 0.95 이상을 먼저 확인한 뒤 테스트 정확도(0.95 이상)를 잽니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "가운데 영역 `img[2:6, 3:5]`의 평균 진하기를 기준값과 비교합니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "digits = load_digits()\n",
    "mask = (digits.target == 0) | (digits.target == 1)\n",
    "img_tr, img_te, d_tr, d_te = train_test_split(digits.images[mask], digits.target[mask], test_size=0.3,\n",
    "                                              random_state=0, stratify=digits.target[mask])\n",
    "center_tr = img_tr[:, 2:6, 3:5].mean(axis=(1, 2))\n",
    "for k in (0, 1):\n",
    "    print(f\"숫자 {k}: 가운데 평균 진하기 5%·50%·95% 지점\", np.percentile(center_tr[d_tr == k], [5, 50, 95]).round(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-029",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def rule_01(img):\n",
    "    return int(img[2:6, 3:5].mean() > 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-030",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "pred01_tr = np.array([rule_01(img) for img in img_tr])\n",
    "assert set(pred01_tr.tolist()) == {0, 1}, \"0과 1을 모두 예측해야 합니다\"\n",
    "train01 = (pred01_tr == d_tr).mean()\n",
    "print(\"0/1 규칙 훈련 정확도:\", round(train01, 3))\n",
    "assert train01 >= 0.95, \"훈련 정확도가 0.95 미만입니다. 기준값을 두 분포 사이로 잡았나요?\"\n",
    "pred01 = np.array([rule_01(img) for img in img_te])\n",
    "acc01 = (pred01 == d_te).mean()\n",
    "print(\"0/1 규칙 테스트 정확도:\", round(acc01, 3))\n",
    "assert acc01 >= 0.95, \"테스트에서 0.95 미만입니다. 기준값이 한쪽 분포 끝에 너무 붙어 있지 않은지 보세요\"\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-031",
   "metadata": {},
   "source": [
    "### 관찰: 0~9 열 개라면?\n",
    "\n",
    "아래 셀은 같은 데이터의 **10종 분류**를 두 가지 머신러닝 모델로 푼다. 실행하고 결과를 읽으세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "Xd_tr, Xd_te, yd_tr, yd_te = train_test_split(digits.data, digits.target, test_size=0.3,\n",
    "                                              random_state=0, stratify=digits.target)\n",
    "logreg = LogisticRegression(max_iter=2000).fit(Xd_tr, yd_tr)\n",
    "deep_tree = DecisionTreeClassifier(random_state=0).fit(Xd_tr, yd_tr)\n",
    "print(\"로지스틱 회귀 10종 정확도:\", round(logreg.score(Xd_te, yd_te), 3))\n",
    "print(\"결정 트리 10종 정확도:\", round(deep_tree.score(Xd_te, yd_te), 3), \"/ 규칙(잎) 수:\", deep_tree.get_n_leaves())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 두 숫자는 규칙 한 줄로 충분했다. 열 개가 되면 획 하나 차이인 쌍(3과 8, 1과 7, 4와 9)이 많아진다. 이번 설정의 깊이 제한 없는 결정 트리는 잎을 100개 넘게 만들었다(잎 하나 = if 규칙 하나). 0/1의 규칙 한 줄보다 훨씬 복잡한 표현이다. 다만 사람이 쓸 규칙의 최소 개수를 잰 것은 아니다. 로지스틱 회귀는 픽셀 64개마다 가중치를 배워 트리보다 잘 맞혔지만, 그 가중치는 사람이 읽는 규칙이 아니다. 이 관찰은 머신러닝 모델 둘을 비교한 것이고, 사람이 쓴 10종 규칙의 정확도는 재지 않았다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-034",
   "metadata": {},
   "source": [
    "## 문제 8. 규칙인가 학습인가 (사례)\n",
    "\n",
    "각 상황에 더 맞는 방법을 `R`(규칙 기반) 또는 `M`(머신러닝)으로 골라 (a)~(d) 순서대로 이어 쓴 문자열을 `q8`에 적으세요.\n",
    "\n",
    "(a) 만 14세 미만은 보호자 동의 없이 가입할 수 없다(법 조항). 가입 화면에서 이것을 막아야 한다.\n",
    "(b) 공장 카메라 사진에서 긁힘 불량을 찾는다. 사람이 불량/정상을 표시한 사진이 수천 장 있다.\n",
    "(c) 주문 금액이 5만 원 이상이면 무료 배송을 적용한다.\n",
    "(d) 고객 문의 글을 10개 담당 부서로 자동 배정한다. 과거에 사람이 배정한 기록이 5만 건 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q8 = \"RMRM\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q8\", q8, \"594ec294a976\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a)(c)는 기준이 법·정책으로 정해져 있고 예외가 없다. 모델로 \"대체로 맞히는\" 것보다 규칙으로 **항상** 지키는 것이 맞다. (b)(d)는 판단 기준을 말로 쓰기 어렵고 정답 달린 예시가 쌓여 있다. 지도 학습이 맞는 조건이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-038",
   "metadata": {},
   "source": [
    "## 문제 9. 규칙이 300개가 된 사기 탐지 (사례)\n",
    "\n",
    "카드사 이상거래 탐지 시스템은 지금까지 사람이 쓴 규칙으로 운영됐습니다. 규칙이 300개를 넘으면서 서로 충돌하고, 사기 수법은 몇 달마다 바뀌어 규칙 수정이 늦습니다. 지난 2년치 거래에는 사기 여부가 확인된 기록이 있습니다. 한편 \"정지된 카드의 결제는 무조건 거절\"은 회사 정책입니다.\n",
    "\n",
    "가장 알맞은 방향을 `q9`에 적으세요.\n",
    "\n",
    "- A. 규칙 담당자를 늘려 새 수법마다 규칙을 더 빨리 추가한다.\n",
    "- B. 사기 여부 기록으로 지도 학습 모델을 만들어 패턴 판단을 맡기고, 정지 카드 거절 같은 정책은 규칙으로 유지한다.\n",
    "- C. 라벨을 쓰지 않는 군집으로 거래를 묶고, 가장 작은 묶음을 사기로 본다.\n",
    "- D. 모든 규칙을 없애고 모델 하나가 모든 결정을 하게 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch01-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-041",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 규칙 수 폭발·충돌·변화에 늦음은 규칙 기반이 막히는 전형적인 신호이고, 정답 기록(사기 여부)이 있으니 지도 학습을 쓸 조건이 된다. 그러나 정책으로 정해진 조건은 모델의 확률 판단에 맡기지 않고 규칙으로 보장한다(D가 틀린 이유). C는 라벨이 있는데 버리는 셈이고, \"작은 묶음 = 사기\"라는 가정도 근거가 없다. 사기처럼 드문 사건을 다룰 때의 평가 지표는 5장에서 본다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch01-042",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 5·6에서 내 규칙과 트리의 규칙이 어디서 같고 어디서 다른지 한 문장으로 적었다.\n",
    "- [ ] 원고 1-7절 선택 기준표의 다섯 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(02장 NumPy)부터 데이터를 숫자 배열로 다룬다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
