{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch02-000",
   "metadata": {},
   "source": [
    "# 02장 실습. 데이터를 숫자로: NumPy\n",
    "\n",
    "**목표:** shape·축·브로드캐스팅을 실행 전에 예측하고, 반복 계산을 루프 없이 쓰고, 표·이미지·텍스트를 모델에 넣을 배열로 바꾼다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 코드 문제는 **파이썬 `for` 루프 없이** 배열 연산으로 쓰는 것이 목표다(문제 8만 예외 허용). 점검은 결과만 보므로 스스로 지킨다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간 30분. 내려받기 없이 CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-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",
    "digits = load_digits()\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",
    "print(\"붓꽃:\", X_tr.shape, X_te.shape, \"/ 손글씨:\", Xd_tr.shape, Xd_te.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-002",
   "metadata": {},
   "source": [
    "## 문제 1. 결과 shape 예측 (개념)\n",
    "\n",
    "`x = np.zeros((5, 3, 4))`일 때 아래 결과의 shape를 **실행하지 말고** 예측해, (a)~(f) 순서대로 튜플의 리스트로 `q1`에 적으세요. 원소가 하나인 튜플은 `(5,)`처럼 씁니다.\n",
    "\n",
    "(a) `x.sum(axis=0)`\n",
    "(b) `x.mean(axis=-1)`\n",
    "(c) `x.max(axis=(1, 2))`\n",
    "(d) `x.sum(axis=1, keepdims=True)`\n",
    "(e) `x[:, 0]`\n",
    "(f) `x.reshape(5, -1)`\n",
    "\n",
    "예: `q1 = [(1, 2), (3,), ...]`\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`axis=k`로 집계하면 k번 축이 사라집니다(`keepdims=True`면 길이 1로 남음). 정수 하나로 인덱싱한 축도 사라집니다. `-1`은 \"나머지 크기로 계산\"입니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q1 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "assert q1 is not None, \"q1: 답을 적으세요\"\n",
    "check(\"q1\", [tuple(s) for s in q1], \"e02d5d65f194\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-005",
   "metadata": {},
   "source": [
    "## 문제 2. 브로드캐스팅 되나 (개념)\n",
    "\n",
    "각 쌍을 `+`로 계산할 수 있으면 `O`, 오류면 `X`. (a)~(e) 순서대로 이어 쓴 문자열을 `q2`에 적으세요. 예: `\"OOXXO\"`\n",
    "\n",
    "(a) `(4, 3)` + `(3,)`\n",
    "(b) `(4, 3)` + `(4,)`\n",
    "(c) `(4, 1)` + `(1, 3)`\n",
    "(d) `(2, 4, 3)` + `(4, 1)`\n",
    "(e) `(5, 2)` + `(2, 5)`\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "뒤쪽 축부터 짝짓고, 축 수가 적은 쪽은 앞에 1을 붙입니다. 짝마다 길이가 같거나 한쪽이 1이어야 합니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q2 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q2\", q2, \"9861f5c5fe42\")\n",
    "pairs = [((4, 3), (3,)), ((4, 3), (4,)), ((4, 1), (1, 3)), ((2, 4, 3), (4, 1)), ((5, 2), (2, 5))]\n",
    "for a, b in pairs:\n",
    "    try:\n",
    "        print(a, \"+\", b, \"→\", (np.zeros(a) + np.zeros(b)).shape)\n",
    "    except ValueError:\n",
    "        print(a, \"+\", b, \"→ 오류\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-008",
   "metadata": {},
   "source": [
    "## 문제 3. 열별 표준화 (코드)\n",
    "\n",
    "`X` (표본 N, 특성 d)를 받아 **열마다** 평균을 빼고 표준편차로 나눈 배열을 돌려주는 `standardize(X)`를 쓰세요. 표준편차는 `np.std`의 기본값(`ddof=0`)을 씁니다. 모든 열의 표준편차는 0보다 크다고 가정합니다(값이 모두 같은 열은 없음). 입력 `X`는 바꾸지 않습니다.\n",
    "\n",
    "점검 셀은 결과를 sklearn `StandardScaler`와 비교합니다(상수 열이 없을 때 둘은 같은 계산입니다).\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`X.mean(axis=0)`은 `(d,)`입니다. `(N, d) - (d,)`는 행마다 같은 벡터를 뺍니다. `X -= ...`처럼 쓰면 입력이 바뀝니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-009",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def standardize(X):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-010",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "rng = np.random.default_rng(1)\n",
    "A = rng.normal(loc=[0, 50, 1000], scale=[1, 10, 300], size=(8, 3))\n",
    "A_before = A.copy()\n",
    "Z = standardize(A)\n",
    "assert Z is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(A, A_before), \"입력 배열이 바뀌었습니다. 새 배열을 만들어 돌려주세요\"\n",
    "assert Z.shape == A.shape, f\"shape가 {Z.shape}입니다. 입력과 같은 {A.shape}여야 합니다\"\n",
    "assert np.allclose(Z, StandardScaler().fit_transform(A)), \"StandardScaler 결과와 다릅니다. 축(axis)과 표준편차 ddof(기본 0)를 확인하세요\"\n",
    "S = rng.normal(size=(3, 3)) * [1, 5, 20]\n",
    "assert np.allclose(standardize(S), StandardScaler().fit_transform(S)), \"정사각 행렬에서 틀립니다. 열(axis=0) 기준인가요?\"\n",
    "print(\"열 평균\", np.abs(Z.mean(axis=0)).round(6), \"열 표준편차\", Z.std(axis=0).round(6))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-011",
   "metadata": {},
   "source": [
    "## 문제 4. 행별 비율 (코드)\n",
    "\n",
    "음수가 없는 개수 표 `C` (N, k)를 받아, 행마다 합이 1이 되도록 나눈 실수 배열을 돌려주는 `row_ratio(C)`를 쓰세요. (모든 행의 합은 0보다 크다고 가정합니다.)\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "행 합 `C.sum(axis=1)`은 `(N,)`입니다. `(N, k)`와 맞추려면 `(N, 1)`이어야 합니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def row_ratio(C):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "C = np.array([[2, 1, 1], [0, 3, 1], [5, 0, 5], [1, 1, 2]])\n",
    "R = row_ratio(C)\n",
    "assert R is not None, \"결과를 return 하세요\"\n",
    "assert R.shape == C.shape, f\"shape가 {R.shape}입니다. 입력과 같아야 합니다\"\n",
    "assert np.allclose(R.sum(axis=1), 1), \"행 합이 1이 아닙니다\"\n",
    "assert np.allclose(R, C / C.sum(axis=1, keepdims=True)), \"값이 다릅니다\"\n",
    "Sq = np.array([[1, 3, 0], [2, 6, 2], [1, 1, 8]])\n",
    "assert np.allclose(row_ratio(Sq).sum(axis=1), 1), \"정사각 행렬에서 행 합이 1이 아닙니다. 열 방향으로 나눈 것은 아닌가요?\"\n",
    "print(R)\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-014",
   "metadata": {},
   "source": [
    "## 문제 5. 가장 가까운 점 찾기 (코드)\n",
    "\n",
    "질의 점 `Q` (m, d)와 데이터 점 `P` (n, d)를 받아, 질의마다 **유클리드 거리**가 가장 가까운 `P`의 행 번호를 담은 `(m,)` 정수 배열을 돌려주는 `nearest(Q, P)`를 쓰세요. 루프 없이 브로드캐스팅으로 거리 행렬 `(m, n)`을 만든 뒤 고릅니다.\n",
    "\n",
    "점검 셀은 이 함수로 **1-최근접 이웃 분류**(가장 가까운 훈련 표본의 품종을 그대로 예측)를 붓꽃에 적용해 봅니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`Q[:, None, :] - P[None, :, :]`는 `(m, n, d)`입니다. 마지막 축으로 제곱합을 구하고 `argmin(axis=1)`. 가장 가까운 점만 찾을 때는 `sqrt`를 생략해도 순서가 같습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def nearest(Q, P):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "rng = np.random.default_rng(2)\n",
    "P5, Q5 = rng.normal(size=(7, 3)), rng.normal(size=(4, 3))\n",
    "idx = nearest(Q5, P5)\n",
    "assert idx is not None, \"결과를 return 하세요\"\n",
    "idx = np.asarray(idx)\n",
    "assert idx.shape == (4,), f\"shape가 {idx.shape}입니다. 질의 수와 같은 (4,)여야 합니다\"\n",
    "ref = np.array([min(range(len(P5)), key=lambda j: np.linalg.norm(q - P5[j])) for q in Q5])\n",
    "assert np.array_equal(idx, ref), \"가장 가까운 점이 다릅니다. 어느 축으로 합치고 어느 축으로 argmin 했는지 보세요\"\n",
    "pred = y_tr[nearest(X_te, X_tr)]\n",
    "acc = (pred == y_te).mean()\n",
    "print(\"붓꽃 1-최근접 이웃 테스트 정확도:\", round(acc, 3))\n",
    "assert acc >= 0.9, \"정확도가 너무 낮습니다\"\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-017",
   "metadata": {},
   "source": [
    "## 문제 6. 코사인 유사도 행렬 (코드)\n",
    "\n",
    "`A` (m, d)와 `B` (n, d)를 받아 `S[i, j]` = `A[i]`와 `B[j]`의 코사인 유사도인 `(m, n)` 배열을 돌려주는 `cos_sim(A, B)`를 쓰세요. 행 길이(노름)로 나눈 뒤 행렬곱 한 번으로 계산합니다. (영벡터 행은 없다고 가정합니다.)\n",
    "\n",
    "점검 셀은 손글씨 숫자 테스트 이미지마다 **훈련 이미지 중 코사인 유사도가 가장 높은 것**을 찾아 숫자가 같은지 봅니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`np.linalg.norm(A, axis=1, keepdims=True)`는 `(m, 1)`입니다. 정규화한 `An @ Bn.T`는 `(m, d) @ (d, n)` → `(m, n)`.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-018",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def cos_sim(A, B):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "rng = np.random.default_rng(3)\n",
    "A6, B6 = rng.normal(size=(3, 5)) * [[1], [10], [0.1]], rng.normal(size=(4, 5))\n",
    "S6 = cos_sim(A6, B6)\n",
    "assert S6 is not None, \"결과를 return 하세요\"\n",
    "assert S6.shape == (3, 4), f\"shape가 {S6.shape}입니다. (m, n) = (3, 4)여야 합니다\"\n",
    "ref = np.array([[a @ b / (np.linalg.norm(a) * np.linalg.norm(b)) for b in B6] for a in A6])\n",
    "assert np.allclose(S6, ref), \"값이 다릅니다. 각 행을 자기 길이로 나눴나요?\"\n",
    "assert np.allclose(cos_sim(A6 * 7, B6), S6), \"코사인 유사도는 벡터 길이를 바꿔도 같아야 합니다\"\n",
    "q = Xd_te[:300]\n",
    "top1 = cos_sim(q, Xd_tr).argmax(axis=1)\n",
    "agree = (yd_tr[top1] == yd_te[:300]).mean()\n",
    "print(\"테스트 이미지 300장 중 가장 비슷한 훈련 이미지와 숫자가 같은 비율:\", round(agree, 3))\n",
    "assert agree >= 0.9, \"검색 결과가 이상합니다\"\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-020",
   "metadata": {},
   "source": [
    "## 문제 7. 이미지 배치를 모델 입력으로 (코드)\n",
    "\n",
    "Pillow로 읽은 이미지를 쌓은 배치 `batch`는 `(N, H, W, C)`, `uint8`(0~255)입니다. PyTorch 모델은 `(N, C, H, W)`, `float32`, 값 0~1을 기대합니다. 변환하는 `to_model_input(batch)`를 쓰세요. 입력은 바꾸지 않습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "축 순서는 `transpose(0, 3, 1, 2)`로 바꿉니다(`reshape` 아님). `astype(np.float32)`로 바꾼 뒤 255로 나눕니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-021",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def to_model_input(batch):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-022",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "rng = np.random.default_rng(4)\n",
    "b7 = rng.integers(0, 256, size=(2, 4, 6, 3), dtype=np.uint8)     # H=4, W=6으로 서로 다르게\n",
    "b7_before = b7.copy()\n",
    "out = to_model_input(b7)\n",
    "assert out is not None, \"결과를 return 하세요\"\n",
    "assert np.array_equal(b7, b7_before), \"입력 배열이 바뀌었습니다\"\n",
    "assert out.shape == (2, 3, 4, 6), f\"shape가 {out.shape}입니다. (N, C, H, W) = (2, 3, 4, 6)이어야 합니다\"\n",
    "assert out.dtype == np.float32, f\"dtype이 {out.dtype}입니다. float32로 바꾸세요\"\n",
    "assert out.min() >= 0 and out.max() <= 1, \"값이 0~1 범위가 아닙니다\"\n",
    "assert np.allclose(out[:, 0], b7[..., 0] / 255), \"채널 0이 원본의 빨강 채널과 다릅니다. reshape는 축 순서를 바꾸지 않습니다\"\n",
    "assert np.allclose(out, b7.transpose(0, 3, 1, 2) / 255), \"값이 다릅니다\"\n",
    "print(out.shape, out.dtype, float(out.min()), float(out.max()))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-023",
   "metadata": {},
   "source": [
    "## 문제 8. 단어 주머니 (코드)\n",
    "\n",
    "아래 셀은 원고 2-7절처럼 문장을 패딩된 ID 배열 `padded` (N, L)로 바꿉니다(0 = 패딩). `bag_of_words(padded, V)`를 쓰세요. 결과는 `(N, V)` 정수 배열이고 `[i, t]` = 문장 i에 ID t가 나온 횟수, **패딩 열(0번)은 0**입니다.\n",
    "\n",
    "원-핫 방법(`np.eye`)으로 먼저 써 보세요. 막히면 루프로 써도 통과합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "sentences = [\"나는 사과 를 먹었다\", \"나는 바나나 를 샀다\", \"사과 를 샀다\", \"사과 사과 사과\"]\n",
    "vocab = sorted({w for s in sentences for w in s.split()})\n",
    "word_to_id = {w: i + 1 for i, w in enumerate(vocab)}\n",
    "\n",
    "def to_padded(sents, w2i):\n",
    "    ids = [[w2i[w] for w in s.split()] for s in sents]\n",
    "    out = np.zeros((len(ids), max(len(x) for x in ids)), dtype=np.int64)\n",
    "    for i, seq in enumerate(ids):\n",
    "        out[i, :len(seq)] = seq\n",
    "    return out\n",
    "\n",
    "padded = to_padded(sentences, word_to_id)\n",
    "V = len(vocab) + 1\n",
    "print(word_to_id)\n",
    "print(padded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-025",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "def bag_of_words(padded, V):\n",
    "    pass   # 작성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-026",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "bow = bag_of_words(padded, V)\n",
    "assert bow is not None, \"결과를 return 하세요\"\n",
    "bow = np.asarray(bow)\n",
    "assert np.issubdtype(bow.dtype, np.integer), f\"dtype이 {bow.dtype}입니다. 개수이므로 정수 배열로 만드세요(np.eye(V, dtype=int))\"\n",
    "assert bow.shape == (len(sentences), V), f\"shape가 {bow.shape}입니다. (N, V) = {(len(sentences), V)}여야 합니다\"\n",
    "assert (bow[:, 0] == 0).all(), \"패딩 열(0번)은 0이어야 합니다\"\n",
    "assert bow[3, word_to_id[\"사과\"]] == 3, \"같은 단어가 여러 번 나오면 개수를 세야 합니다\"\n",
    "rng = np.random.default_rng(5)\n",
    "rp = rng.integers(0, 9, size=(6, 5))\n",
    "ref = np.zeros((6, 9), dtype=int)\n",
    "for i, row in enumerate(rp):\n",
    "    for t in row:\n",
    "        if t:\n",
    "            ref[i, t] += 1\n",
    "bow_r = np.asarray(bag_of_words(rp, 9))\n",
    "assert np.issubdtype(bow_r.dtype, np.integer), \"다른 입력에서도 정수 배열이어야 합니다\"\n",
    "assert np.array_equal(bow_r, ref), \"다른 입력에서 개수가 다릅니다\"\n",
    "print(bow)\n",
    "pair = [\"철수 가 영희 를 도왔다\", \"영희 가 철수 를 도왔다\"]\n",
    "w2 = {w: i + 1 for i, w in enumerate(sorted({w for s in pair for w in s.split()}))}\n",
    "b2 = bag_of_words(to_padded(pair, w2), len(w2) + 1)\n",
    "print(\"순서만 다른 두 문장의 단어 주머니가 같은가:\", bool((b2[0] == b2[1]).all()))\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-027",
   "metadata": {},
   "source": [
    "## 문제 9. 오류 없이 틀리는 전처리 (사례)\n",
    "\n",
    "동료가 사진 32장을 `x` (32, 224, 224, 3), `uint8`로 읽어, 입력이 `(N, 3, 224, 224)` float 0~1인 PyTorch 모델에 넣었습니다.\n",
    "\n",
    "```python\n",
    "x = x + 30                                # 사진이 어두워 밝기를 올림\n",
    "x = x.reshape(32, 3, 224, 224) / 255\n",
    "```\n",
    "\n",
    "오류 없이 실행되지만 예측이 거의 무작위입니다. 원인과 고칠 방법을 바르게 짚은 것을 `q9`에 적으세요.\n",
    "\n",
    "- A. `reshape`는 축 순서를 바꾸지 않아 채널이 뒤섞인다 → `transpose(0, 3, 1, 2)`. 또 `uint8`에 30을 더하면 255를 넘는 픽셀이 작은 값으로 돌아간다 → 먼저 실수로 바꾼 뒤 더하고 0~255로 자른다(`np.clip`).\n",
    "- B. `/ 255`가 정수 나눗셈이라 모두 0이 된다 → `// 255`로 바꾼다.\n",
    "- C. 코드는 맞다. 224×224가 너무 커서 모델이 읽지 못하므로 32×32로 줄인다.\n",
    "- D. `uint8` 덧셈은 255에서 멈추므로 문제없다. `reshape` 대신 `x.T`를 쓰면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q9 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-029",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"559aead08264\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-030",
   "metadata": {},
   "source": [
    "## 문제 10. 단어 주머니로 충분한가 (사례)\n",
    "\n",
    "단어는 **띄어쓰기로 나눈 단위**로 셉니다(원고 2-7절과 같음). 각 과제에 단어 주머니 + 고전 머신러닝으로 출발해도 되면 `B`, 단어 순서를 다루는 표현(시퀀스 모델·임베딩)이 꼭 필요하면 `S`. (a)~(d) 순서대로 이어 쓴 문자열을 `q10`에 적으세요.\n",
    "\n",
    "(a) 상품 리뷰 2만 건을 긍정/부정으로 나누는 **첫 기준선**을 오늘 안에 만든다.\n",
    "(b) \"고양이가 쥐를 쫓았다\"와 \"쥐가 고양이를 쫓았다\"를 구분해, 쫓은 쪽이 누구인지 답한다. 두 문장은 띄어쓰기 단위로 `고양이가`·`쥐를`처럼 붙어 있지 않고 `고양이 가 쥐 를 쫓았다` / `쥐 가 고양이 를 쫓았다`로 조사가 나뉘어 들어온다고 가정한다.\n",
    "(c) 뉴스 기사를 스포츠·경제·정치 중 하나로 분류한다.\n",
    "(d) \"환불은 되지만 교환은 안 됩니다\"와 \"교환은 되지만 환불은 안 됩니다\"를 구분해 고객에게 안내한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 작성하세요\n",
    "q10 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"0a1881d26c3e\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-033",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 3·4에서 `axis`와 `keepdims`를 왜 그렇게 골랐는지 한 문장으로 적었다.\n",
    "- [ ] 문제 7에서 `reshape`로 바꾸면 어떤 점검이 실패하는지 직접 바꿔 확인했다.\n",
    "- [ ] 원고 2-8절 선택 기준표의 네 줄을 내 말로 다시 적어 두었다.\n",
    "\n",
    "다음 장(03장 pandas)에서는 열 이름과 서로 다른 자료형이 섞인 표를 다룬다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
