{
 "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 = [(3, 4), (5, 3), (5,), (5, 1, 4), (5, 4), (5, 12)]"
   ]
  },
  {
   "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": [
    "> **해설**\n",
    ">\n",
    "> (a) 축 0(길이 5)이 사라져 `(3, 4)`. (b) `-1`은 마지막 축이므로 `(5, 3)`. (c) 축 1·2가 함께 사라져 `(5,)`: 표본마다 값 하나. (d) 축 1이 길이 1로 남아 `(5, 1, 4)`. 나중에 `(5, 3, 4)`와 브로드캐스팅할 때 이 모양이 필요하다. (e) 축 1을 정수로 골라 `(5, 4)`. (f) 원소 60개를 5행으로 자르면 `(5, 12)`. 이미지 묶음 `(N, H, W)`를 표 `(N, H×W)`로 펼 때 쓰는 모양이다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-006",
   "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-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q2 = \"OXOOX\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-008",
   "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-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a) 뒤쪽 3과 3 → `(4, 3)`. (b) 뒤쪽 3과 4가 달라 오류. 행마다 다른 값을 더하려면 `(4, 1)`로 바꿔야 한다. (c) 양쪽이 늘어나 `(4, 3)`. (d) `(4, 1)`을 `(1, 4, 1)`로 보면 `(2, 4, 3)`. (e) 뒤쪽 2와 5가 달라 오류. `(2, 5)`를 `.T`로 바꾸면 계산된다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-010",
   "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-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def standardize(X):\n",
    "    return (X - X.mean(axis=0)) / X.std(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-012",
   "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-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `(N, d) - (d,)`는 뒤쪽 축 d가 맞아 행마다 같은 평균 벡터를 뺀다. 정사각 행렬에서는 `axis=1`로 잘못 써도 오류가 나지 않으므로 결과의 성질(열 평균 0, 열 표준편차 1)로 확인한다. sklearn `StandardScaler`도 같은 계산이다. 다만 값이 모두 같은 열(표준편차 0)이 있으면 이 함수는 0으로 나눠 `nan`이 되고, `StandardScaler`는 그 열을 나누지 않아 0으로 둔다. 또 평균·표준편차를 **훈련 데이터에서만** 구해 테스트에도 그 값을 써야 한다(5장 데이터 누수)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-014",
   "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-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def row_ratio(C):\n",
    "    return C / C.sum(axis=1, keepdims=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-016",
   "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-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `keepdims=True`로 행 합을 `(N, 1)`로 남기면 `(N, k) / (N, 1)`이 행마다 자기 합으로 나눈다. 정사각 행렬에서 `C / C.sum(axis=1)`은 오류 없이 **열 방향**으로 나눠 틀린 답을 낸다. 그래서 점검은 \"행 합이 1인가\"라는 성질로 했다. 이 계산은 개수를 확률 분포로 바꿀 때(16장 다음 토큰 확률) 다시 나온다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-018",
   "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-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def nearest(Q, P):\n",
    "    D2 = ((Q[:, None, :] - P[None, :, :]) ** 2).sum(axis=-1)\n",
    "    return D2.argmin(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-020",
   "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-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `(m, 1, d) - (1, n, d)`가 모든 쌍의 차이 `(m, n, d)`를 만들고, 좌표 축(마지막)을 합치면 거리 행렬 `(m, n)`, 각 행에서 `argmin`이 가장 가까운 점이다. 붓꽃에서는 학습 없이 \"가장 비슷한 훈련 표본 따라 하기\"만으로 1장의 규칙·트리와 비슷한 정확도가 나온다. 이것이 k-최근접 이웃(8장)이다. 중간 배열이 m×n×d이므로 데이터가 크면 질의를 묶음으로 나눠 계산한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-022",
   "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-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def cos_sim(A, B):\n",
    "    An = A / np.linalg.norm(A, axis=1, keepdims=True)\n",
    "    Bn = B / np.linalg.norm(B, axis=1, keepdims=True)\n",
    "    return An @ Bn.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-024",
   "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-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 행마다 길이 1로 나누면 내적이 곧 코사인 유사도다. 행렬곱 한 번으로 300×1257쌍을 계산했다. 질의 하나에 대해 유사도가 높은 순으로 고르면 **벡터 검색**이고, 17장 임베딩 검색·RAG는 픽셀 대신 문장 임베딩으로 같은 계산을 한다. 코사인은 길이를 무시하므로 같은 숫자를 진하게 쓴 이미지와 연하게 쓴 이미지가 비슷하게 나온다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-026",
   "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-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def to_model_input(batch):\n",
    "    return batch.transpose(0, 3, 1, 2).astype(np.float32) / 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-028",
   "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-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `transpose(0, 3, 1, 2)`는 \"새 축 순서 = 옛 축 N, C, H, W\"다. `reshape(N, C, H, W)`는 shape만 같고 픽셀 값이 채널 사이로 뒤섞인다. 오류가 나지 않으므로 모델 정확도가 이유 없이 낮게 나온다. 0~1로 나누기 전에 실수로 바꾸는 것도 중요하다(밝기 보정 같은 덧셈을 `uint8`에서 하면 255를 넘는 값이 작은 값으로 돌아간다). torchvision `ToTensor`가 이 변환을 한 장 단위로 해 준다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-030",
   "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-031",
   "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-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def bag_of_words(padded, V):\n",
    "    bow = np.eye(V, dtype=int)[padded].sum(axis=1)   # (N, L, V) → (N, V)\n",
    "    bow[:, 0] = 0\n",
    "    return bow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-033",
   "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-034",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `np.eye(V)[padded]`는 정수 배열로 단위행렬의 행을 골라 `(N, L, V)` 원-핫을 만들고, 단어 축(1)을 합치면 단어 개수 `(N, V)`가 된다. 패딩도 ID 0으로 세어지므로 0번 열을 지운다. 마지막 줄처럼 단어 주머니는 순서를 버려 \"누가 누구를\"을 구분하지 못한다. 어휘가 수만 개면 대부분 0인 큰 표가 되므로 실무에서는 sklearn `CountVectorizer`가 0이 아닌 값만 저장하는 희소 행렬로 만든다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-035",
   "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-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"A\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-037",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"559aead08264\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-038",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 두 가지 모두 **오류도 경고도 없이** 값을 망가뜨린다. B: NumPy의 `/`는 정수 배열도 실수 결과를 내고, `//`는 오히려 0·1만 남긴다. C: 모양 `(N, 3, 224, 224)`는 맞다. 문제는 그 안의 값 배치다. D: `uint8`은 255에서 멈추지 않고 256으로 나눈 나머지로 돌아간다(250+30 → 24). 또 `x.T`는 모든 축을 뒤집어 `(3, 224, 224, 32)`가 된다. 점검 습관: 변환 뒤 한 장을 그려 보거나, `out[0, 0]`이 원본 빨강 채널 `x[0, :, :, 0]`과 같은지 확인한다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-039",
   "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-040",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q10 = \"BSBS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch02-041",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q10\", q10, \"0a1881d26c3e\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-042",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> (a)(c)는 \"어떤 단어가 나왔나\"(최고, 별로, 경기, 금리)가 답을 크게 좌우하므로 단어 주머니로 빠르게 기준선을 만들고, 부족하면 그다음에 큰 모델을 쓴다. (b)(d)는 두 문장을 띄어쓰기로 자르면 같은 단어가 같은 개수로 나오고 **순서만** 다르다((d)는 `환불은`·`되지만`·`교환은`·`안`·`됩니다` 다섯 개가 그대로 자리만 바뀐다). 단어 주머니로는 두 문장이 같은 벡터가 되므로 구분할 수 없다. 순서를 다루는 모델(13장 RNN, 14장 트랜스포머)이 필요하다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch02-043",
   "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
}
